ThumbOlly: Utilidad para generar galerías de imágenes de forma rápida y sencilla

Hoy os presento una nueva inutilidad, made in Ollydbg (bueno, quizás esta vez no sea tan inútil xD)

Se trata de ThumbOlly 

 ThumbOlly

 

Bien, esta inutilidad sirve para generar una imagen (en formato png) que contiene las miniaturas de todas las imágenes (bmp, jpg y png) de una serie de carpetas. Lo entenderéis rápido cuando muestre los ejemplos.

La aplicación es realmente simple, dos botones y a correr.

La primera vez que se ejecuta muestra una pantalla de parámetros que no tiene ningún misterio: Carpeta donde se va a guardar la foto resultante, color de fondo y tamaño: 

La aplicación es tan simple de usar como seleccionar la carpeta donde tenemos nuestras imágenes pulsando en el botón Carpeta e iniciar el proceso pulsado en el botón Inicar. No tiene más complicación:

Aquí algunos ejemplos de los resultados obtenidos:

Otro ejemplo más:

Último ejemplo:

 

He incluido dos descargas. Una utiliza el .NET Framework 2 y la otra el .NET Framework 4

Si utilizas Windows 8/8.1 te recomiendo la descarga del .NET Framework 4 

 

Estoy abierto a cualquier mejora que me indiquéis, ya bien sea vía comentario, Mensaje Privado de ZonaForo o por Twitter. 

 

Saludos.
mov eax,ollydbgInt 13h  

Descargar ThumbOlly (.NET Framework 2)
119 KB

 

Descargar ThumbOlly (.NET Framework 4) (Windows 8)
119 KB

 


Ollydbg ProSignature   

.NET Tutorial 63: Tres alternativas para generar Logs (‘propio’, ‘System.Diagnostics’ y ‘log4net’)

Hoy veremos tres formas de poder generar logs para nuestras aplicaciones.

Antes de empezar, decir que los logs pueden ser increiblemente valiosos a la hora de detectar problemas en nuestras aplicaciones. Gracias a los logs podremos ver que es lo que hace nuestra aplicación "en producción". Obviamente, el "nivel de detalle" lo pone el programador. Cuanto más detalle más información, pero también "más información" a examinar en el log.

1. Hágalo Vd. Mismo

Normalmente un log no deja de ser un fichero de texto, con información que escribimos. Una forma "rápida y sencilla" es montarse una rutina que precisamente hace eso, añadir a un fichero de texto lo que queremos guardar.

En este caso tenemos algo muy simple:


(Haz click para agrandar)

El código completo de esta clase la podéis encontrar aquí [vía pastebin]  

Como podéis ver, es una pequeña clase que tiene un método público llamado Write, el cual tiene dos argumentos: el nivel de log y los datos que se escriben en dicho log.

El nivel de log lo uso para diferenciar errores "criticos" de información "normal". De esa forma, si tengo que examinar el log con el bloc de notas, notepad++ u otra herramienta, puedo filtrar rápidamente los logs según su nivel.

Para usar este log en la alplicación es tan simple como definir el siguiente objeto:

private static MyLogClass Log;

Inicializaremos nuestro objeto de esta forma:

Log = new MyLogClass(@"c:temp", "Form1"); 

Y para llamarlo usaremos el método Write:

Log.Write(MyLogClass.LogLevel.Info, "Probando");

El resultado puede ser algo como esto:


(Haz click para agrandar) 

Como véis, es algo muy muy muy básico, pero que puede servir.

 

2. System.Diagnostics

El propio .NET Framework nos proporciona un namespace con el cual podermos hacer algo "similar" a lo explicado en el punto anterior, con la salvedad de que no tenemos que preocuparnos de la escritura del fichero. Este namespace es System.Diagnostics [vía MSDN]

System.Diagnostics nos propociona una serie de "listeners" [link MSDN]  con los cuales se pueden generar logs en ficheros de texto, en XMLs, en el evento de logs de Windows y en el evento de logs de IIS.

Básicamente, se usa el App.Config (o Web.Config para una aplicación Web) para definir nuestros "listeners": 

Nota: Todo lo que se hace en el App.Config / Web.Config se podría haber declarado en el código, pero en este tutorial uso un App.Config por cuestiones de comodidad.

Para usar estos listeners en nuestro código lo primer que hay que hacer es importar el namespace:

using System.Diagnostics;

Y para usarlo algo tan simple como esto:

Trace.TraceInformation("prueba");

Si en nuestra configuración tenemos desactivado el "autoflush" (autoflush="false") deberemos usar:

Trace.Flush();

despues de cada escritura en el log. 

Trace dispone de varios "niveles" de log:

TraceInformation
TraceWarning
TraceError

Cada uno de estos niveles sirve como en el caso anterior, para poder "filtrar" de forma rápida el fichero de log. 

Un ejemplo, usando un TextWriterTraceListener, podría ser este:


(haz click para agrandar)

 

3. Usando log4net

Llegados a este punto, veremos que vamos a dar un "salto de calidad" considerable sin apenas modificar el código.

log4net es un framework desarrollado por la Apache Software Foundation (si, los mismos que han desarrollado el servidor Apache, posiblemente el servidor HTTP más utilizado en el mundo)

La idea, al igual que el punto 2, donde usabamos System.Diagnostics, es tener un App.Config / Web.Config con una serie de "listeners".

En nuestro proyecto, añadiremos una referencia a log4net, normalmente via nuget.

Una vez añadida la referencia, en nuestro punto de entrada añadiremos esta línea para que log4net utilice nuestro App/Web/.config:

[assembly: log4net.Config.XmlConfigurator(Watch = true)] 

En un programa C#, esto normalmente se hace en el Program.cs

Para utilizar log4net en nuestras clases solo tendremos que hacer dos cosas:

using log4net;

Declarar un objeto de tipo ILog de esta forma: 

static readonly ILog Log = LogManager.GetLogger(nombre);  

aquí un ejemplo, para un formulario, de nombre "Form1":


(Haz click para agrandar)

Para usar nuestro log lo único que tendremos que hacer es lo siguiente:

Log.Debug("prueba");
Log.Info("prueba");
Log.Warn("prueba");
Log.Error("prueba");
Log.Fatal("prueba);

y listo 🙂

Al igual que en los casos anteriores, se utilizan "niveles" de log. De esta forma podremos filtrar de forma rápida la información (ver de forma rápida solo los errores, solo los warnings, etc).

Bien, los listeners los definimos en nuestro App/Web.config: 


(Haz click para agrandar)

Listado completo aquí [vía pastebin]  

Aunque yo solo he usado 7, existen muchos más. En la página de ejemplos de log4net encontrarás sus respectivas definiciones.

Bien, si has leído por encima este tutorial y has llegado hasta aquí, quizás estás preguntándote que ventajas supone usar log4net frente a los dos alternativas que vimos antes.

Pues te explico:

Sin tocar nada de código podrás hacer lo siguiente:

– Generar tus logs en bases de datos (Access, SQL Server, MySQL, Oracle, etc)

– Hacer "rollings" de forma transparente, por tamaño o por fecha

– Enviar los logs "en tiempo real" vía UDP, TCP/IP

– Definir el "nivel" de los logs generados, con lo cual puedes tener un log solo con errores, otro con información de depuración, otro con "warnings", etc.

– Enviar los logs a una dirección de correo vía SMTP

-etc.

Repito, todo esto sin tocar para nada tu codigo, solo añadiendo "appenders" y configurando el App/Web Config 

Como ejemplo de este tutorial se han creado estos logs:

El contenido es configurable con la opción layout del App.Config:


(Haz click para agrandar)

Aquí podrás encontrar información adicional sobre el layout

Pir último indicar que el appender "consola", no solo sirve para aplicaciones de tipo consola, tambíen sirve para imprimir el log en la ventana "Resultados" de Visual Studio:


(Haz click para agrandar)

 

Bonus Track

Como complemento, indicar que existen multitud de "visores de logs". Algunos de pago y otros gratuitos. Entre los gratuitos destaco Log2Console.

Desde su página de CodePlex podréis acceder no solo a las últimas versiones, sino también al código fuente. 


(Haz click para agrandar)

La verdad es que es una gozada tener un appender via UDP y estar ejecutando tu aplicación en un PC (llamemosle PC A)  

Desde otro PC (llamemosle PC B) puedo estar ejecutando Log2Console y ver en "tiempo real" los logs de la aplicación que se está ejecutando en el PC A.

Ahora imagina que el PC A está en Seattle y que el PC B está en Sacramento…sobrán las palabras

 

Saludos.
mov eax,ollydbgInt 13h  

Descargar Tutorial63 (Visual Studio 2010 / C# / log4net 2.0.3)
(3,79 MB .NET Framework 4)  

 


Ollydbg ProSignature  

Entity Framework + SQL CE 3.5 + Visual Studio 2010 y campos autonuméricos

Hoy veremos que si trabajamos con Entity Framework + SQL Compact Edition 3.5 (que es la versión que viene por ‘defecto’ con Visual Studio 2010) podemos tener problemas con los campos de tipo autonumérico.

Hay dos soluciones para evitar esto:

a) La más obvia pasa por no usar campos autonuméricos en nuestras entidades y substituirlos por campos de tipo "string" que se llenarán por código con un guid, como puede ser por ejemplo: autor.id = Guid.NewGuid().ToString();

b)  La otra posibilidad pasa por usar SQL Server Compact 4.0 que es lo que vamos hacer en este tutorial

El primer paso, es instalar SQL Server Compact 4.0 y unas "tools" para poder manipular bases de datos de SQLce4.0 desde Visual Studio 2010.

Para ello, usaremos el Microsoft Web Platform Installer e instalaremos estos dos paquetes: 


(haz click para agrandar)

Bien, vamos a crear una aplicación muy simple para ver que sucede cuando se usa una base de de datos sqlce 3.5 y que sucede cuando se usa otra sqlce4.0

Lo primero, creamos una solución vacia y agregamos un proyecto de Biblioteca de clases.

Borramos el archivo Class1.cs/vb y agregamos dos bases de datos, una será Base de datos local (sqlce3.5) y otra será Base de datos local de SQL Server Compact 4.0: 


(haz click para agrandar)

Nota: Lo hacemos así "rápido". Otra forma, sería crea las bases de datos desde el Explorador de Servidores, agregando una nueva conexión y estableciendo el origen de datos como SQLce 3.5 o SQLce 4.0

Bueno, el caso es que al final tenemos algo como esto: 

Nota: Al agregar una base de datos SQLce 4.0 se nos agrega automáticamente una referencia a System.Data.SqlServerCe que hace referencia a una dll de la versión "4" del SQL Compact Edition 4.0

Bien, añadimos a nuestro proyecto de biblioteca de clases un nuevo ADO.NET Entity Model vacio y agregamos una entidad "Autor" cuyo campo id es de tipo autonumérico.

El resto de campos son de tipo "string" (nvarchar)

Sobre el modelo de entidades, pulsamos botón derecho y seleccionamos Generar base de datos desde el modelo: 


(haz click para agrandar)

Como veís aquí está el primer "problema". En modelo de entidades solo se puede aplicar a una base de datos de SQL Server o SQL ce 3.5, no 4.0.

Esto es una "limitación" de Visual Studio 2010. De todas formas, dont panic.

Elegimos el origen de datos SQLce3.5: 


(haz click para agrandar)

y seleccionamos nuestra base de datos (la base de datos existe pero no tiene ninguna tabla) SQLce3.5 que añadimos al principio:


(haz click para agrandar)

Estos pasos en realidad no generan la base de datos, generan un script para genera las tablas en dicha base de datos: 


(haz click para agrandar)

Ejecutamos el script (botón derecho, ejecutar) se nos pide una conexión, seleccionamos la base de datos correspondiente y voilá, ya tenemos la tabla de nuestro modelo de entidades en la base de datos.

Para comprobarlo, nos vamos a nuestro explorador de servidores y agregamos una nueva conexión: 


(haz click para agrandar)

Nota: fíjate que aquí si que se puede seleccionar SQL ce 4.0, debido a que tenemos instaladas las "tools" de SQLce 4.0 para Visual Studio 2010.

Bueno, el caso que que una vez añadida la conexión podemos ver que efectivamente, se ha creado la tabla de nuestro modelo de entidades den la base de datos SQLce 3.5: 


(haz click para agrandar)

Bien, segundo paso. Vamos a crear una aplicación que consuma nuestro modelo de entidades, en este caso una aplicación Windows Form de toda la vida.

Para ello agregamos un nuevo proyecto a nuestra solución llamado DemoApp de tipo Windows Form, agregamos una referencia a nuestra librería de clases, copiamos el App.Config de nuestra librería de clases en este nuevo proyecto y por último agregamos un modelo vacio de ADO.NET Entity model que inmediatamente borraremos. Esto último solo lo hacemos para que Visual Studio añada las referencias de System.Data.xxxx necesarias para poder consumir nuestro modelo.

Bien, al final tendremos algo como esto: 

En nuestro formulario, añadimos un control botón que tendrá el código para añadir un autor a la tabla de autores.

El código es realmente simple y no tiene mayor misterio: 


(haz click para agrandar)

Ponemos un breakpoint en db.SaveChanges(); puesto que "sabemos" que esta insercción va a fallar debido a que la base de datos en SQL ce 3.5 y efectivamente, así sucede:


(haz click para agrandar)

Como se puede ver la execepción no deja lugar a dudas: "SQL Server Compact no admite claves y valores generados por el servidor."

Pues vaya… 🙁

Solución quiero!!! 

Lo primero, en el App.Config que nuestra librería de clases cambiaremos la cadena de conexión para indicar que el modelo de entidades usará SQLce 4.0 en lugar del 3.5:


(haz click para agrandar)

En nuestro en el explorador de soluciones, seleccionaremos nuestor modelo de entidades (.edmx) y con el botón derecho seleccionaremos la ocpión "Abrir con…" y seleccionamos la opción "Editor XML":

Esto nos muestra el modelo de entidades en formato XML. Cambiaremos el Provider y ProviderManifestToken por System.Data.SqlServerCe.4.0 y 4.0 respectivamente:


(haz click para agrandar)

Guardarmos los cambios.

Nos vamos al script de generación de la base de datos, nos desconectamos (importante) y volvemos a ejecutar el script. Ahora seleccionamos la base de datos SQLce4.0: 


(haz click para agrandar)

Copiamos de nuevo el App.Config de la libreria de clases en nuesta DemoApp y ejecutamos nuestra mega-aplicación y…premio. Se guarda (y genera) el registro en la base de datos, esta vez, sin ninguna excepción:


(haz click para agrandar)

Os dejo este enlace de un MVP de SQL CE que contiene numerosas herramientas para trabajar con SQL CE, que van desde integración en Visual Studio, hasta herramientas de migración (como el caso de SqlCeCmd) de 3.5 a 4.0 y un montón de cosas mas.

Nota: Con SQL Server Management Studio 2008 (R2 incluido) puedes trabajar con bases de datos SQLce 3.5, pero no con SQLce 4.0 (link de StackOverflow que lo deja bastante claro) y las versiones superiores (Management Studio 2012 ya no tiene soporte para SQLce)

 

Saludos.
mov eax,ollydbgInt 13h

 


 

Ollydbg ProSignature 

.NET Tutorial 61: Jugando con GitHub e introducción a las pruebas unitarias (Parte I)

En este ‘tocho’ tutorial intentaré enseñaros dos cosas:

– Configurar un proyecto de Visual Studio para trabajar con GitHub

– Una muy breve introducción a las pruebas unitarias 

En esta entrada (Git para ‘pobres’) ya vimos como usar Git con una cuenta de DropBox. En la actualidad, el portal GitHub es probablemente el portal más ‘popular’ de repositorios de código abierto para proyectos colaborativos que utiliza Git para el control de versiones.

En las entradas anteriores ya hablamos como instalar Git, con lo cual os remito a dichas entradas para profundizar más en el tema.

Lo primero que deberíamos hacer es descargar las "Git Extensions": https://code.google.com/p/gitextensions/

Las "Git Extensions" funcionan como una software independiente con lo cual se podrá realizar todo lo comentado con respecto al tema de Git incluso en las versiones "Express" de Visual Studio.

En las versiones "Professional", "Premium" y/o "Ultimate" de Visual Studio es posible realizar acciones adicionales, pero que tampoco son "vitales".

 

GitHub

Lo primero que deberemos hacer es crearnos una cuenta en la página de GitHub para poder crear nuestros repositorios de código. Así que ya estás haciendo clic en esta dirección https://github.com/ y creandote una nueva cuenta.

Una vez creada la cuenta, ya podrás crear tus repositorios de código abierto. 


(Haz click para agrandar)

En esa pantalla deberás apuntarte la dirección SSH de tu repositorio. La necesitaremos más tarde para configurar por primera vez nuestro proyecto de Visual Studio.

También deberás añadir una "clave de publicación" (ahora veremos como se genera dicha clave, tranquilo). Para ello pulsa en el icono de opciones: 


(Haz click para agrandar)

Selecciona Deploy Keys. 


(Haz click para agrandar)

Y en Add deploy key pega tu clave pública. (repito, más tarde veremos como se genera esa clave)

Si tienes Visual Studio Professional o superior, es recomendable establecer el control de código fuente a Git:


(Haz click para agrandar)

El proveedor con control de código Git lo puedes instalar mediante el administrador de extensiones de Visual Studio (repito, solo versiones Professional o superior)

Para ello busca en Galería en línea:

 
(Haz click para agrandar)

y busca "git" (sin las comillas):


(Haz click para agrandar)

Deberás ver el "Git Source Control Provider". Simplemente seleccionalo y dale a instalar (es posible que te pida reiniciar Visual Studio)

Bien, empiezan los primeros pasos. Todo lo que explicaré a continuación sólo hay que hacerlo la primera vez que se crea el proyecto. 

Creamos nuestro proyecto en Visual Studio y sobre la solución pulsamos botón derecho y vemos lo siguiente:


(Haz click para agrandar)

Deberemos pulsar en la opción "Create Git Repository". Esto prepara el directorio de nuestro proyecto de Visual Studio con una serie de ficheros / carpetas que serán necesarias para las gitextensions.

A continuación pulsamos en este icono:

Esto nos mostrará la pantalla de configuración de las "git extensions":


(Haz click para agrandar)

Lo primero que deberemos hacer es generar nuestra clave pública/privada para poder acceder a GitHub. Para ello pulsaremos en Remotos >> PuTTY >> Generar o importar clave:


(Haz click para agrandar)

Se mostrará la siguiente pantalla. Pulsa en Generar: 

A continuación mueve el ratón por la pantalla para generar números "aleatorios" que se usarán en la generación de tu clave:

Una vez generada la clave verás la siguiente ventana:

Primero, copia toda la public key en el portapaples. Usaremos ese texto copiado para pegarlo en la página de la "Deploy key" de GitHub que vimos al principio.

Introduce una contraseña, la que quieras, pero recuerdala.

Puedes guardar tanto la public key como la private key (la private key tendras que guardarla si o si, ya que la necesitaremos para el siguiente paso)

Bien, siguiente paso. Iniciar el agente de autenticación:


(Haz click para agrandar)

Para ello pulsa en Remotos >> PuTTY >> Iniciar agente de autenticación

Verás que en tu barra de tareas de Windows se muestra el agente. Haz click con el botón derecho sobre él y selecciona Add Key:

A continuación busca el fichero con tu clave privada que guardaste antes.

Te pedirá que introduzcas la contraseña que pusiste cuando se generaron las claves.

Paso final. Configurar el repositorio remoto.


(Haz click para agrandar)

Pulsa en Remotos >> Adminstrar repositorios remotos

Se mostrará esta pantalla:

Cosas importates aquí:

En nombre, deberás usar el nombre con el que te has registrado en GitHub

En Url escribe la dirección SSH de tu repositorio (la que vimos en la primera imagen)

Estas direcciones siempre son del tipo:

git@github.com:TUNOMBRE/NombreRepositorio

En PuTTY SSH carga de nuevo tu clave privada, para ello pulsa en Examinar y busca el archivo.

Es importante probar la conexión. Es muy posible que veas una pantalla "negra" pidiendote guardar tus credenciales en una cache. Responde Yes.

Por último, pulsa en Guardar para guardar la configuración de este repositorio remoto.

Si todo es correcto, el primer "commit" debería completarse correctamente.


(Haz click para agrandar)

Para ello pulsa en Commit

Verás la siguiente pantalla: 


(Haz click para agrandar)

Selecciona todos los ficheros pulsado en la flecha indicada.

Finalmente, escribe el motivo del commit y pulsa en Commit y Push:


(Haz click para agrandar)

Si todo es correcto, ahora en tu página de GitHub verás todos los archivos que has subido a tu repositorio.

Si refrescas la solución de Visual Studio ahora veras los "típicos iconos de código de versiones" al lado de los archivos:

 

En la pantalla principal de las "gitextensions" ahora deberías ver que tu código está sincronizado con el código de la rama master que se encuentra en el repositorio de GitHub.


(Haz click para agrandar)

Si ahora por ejemplo, añadimos una nueva clase:

 

Nos vamos a las "gitextensions":


(Haz click para agrandar)

Pulsamos la tecla F5 (o en su defecto Archivo >> Actualizar) y veremos:


(Haz click para agrandar)

Vemos que tenemos un cambio pendiente (precisamente la clase que hemos añadido). Pulsamos en Commit


(Haz click para agrandar)

Pulsamos en la flecha para añadir nuestro archivo, escribimos el motivo del commit y finalmente pulsamos en Commit y Push. Con lo que "subiremos" ese cambio a nuestro repositorio de GitHub.

La única diferencia con respescto a Visual Studio Professional y superiores con respecto a las versiones Express son que como en las versiones Professionales es posible establecer el control de versiones integrado en el propio IDE, veremos esto:


(Haz click para agrandar)

Desde esa pantalla podremos hacer los commits.

Bien, pues esta la la primera parte de este tutorial.

En la segunda parte veremos como realizar pruebas unitarias y hablaremos un poco de la covertura de código.

Si alguien está interesado, el código completo está en el siguiente repositorio 🙂

git@github.com:kernelENREK/tutorial61.git

o bien

https://github.com/kernelENREK/tutorial61

 

 Tags: Git & GitHub, Git para torpes, tutorial Git, Git en Visual Studio, Desarrollo Social, Social Coding

 

Saludos.
mov eax,ollydbgInt 13h

 


Ollydbg ProSignature

 

Insertar vídeos de YouTube en gamefilia: Tutorial para torpes

Hace ya bastane tiempo que no se pueden insertar vídeos de YouTube en gamefilia con el enlace "compartir" que proporciona el propio YouTube.

La solución pasa por ‘trastear’ el código HTML de la entrada. No es para nada complicado y ahora veremos como se hace.

Supongamos que queremos insertar el siguiente vídeo:


(click para agrandar) 

Todos los vídeos de YouTube tienen un identificador de 11 caracteres.  Deberemos anotar este ‘id’ ya que será el que necesitaremos modificar en nuestro código HTML.

Supongamos que tenemos una entrada tal que así:

Pulsaremos en la opción "Activar editor de texto enriquecido". Esto nos muestra el código HTML de nuestra entrada:

Lo que deberemos hacer es sustituir el código HTML remarcado por esto:

<p>
<object width="420" height="300">
<param name="movie" value="http://www.youtube.com/v/XXXXXXXXXXX" />
<param name="allowfullscreen" value="true" />
<embed width="420" height="300" type="application/x-shockwave-flash" src="http://www.youtube.com/v/XXXXXXXXXXX" allowfullscreen="true" />
</object>
</p> 

Lo único que habrá que hacer es cambiar las XXXXXXXXXXX por la ‘id’ del vídeo que queremos insertar 

 

Finalmente pulsaremos en "Activar editor de texto enriquecido" para ver como se "visualiza" nuestra entrada

Vemos que efectivamente, se ha insertado "un objeto swf". Si usamos la vista previa, voilá:

 

 

Saludos.
mov eax,ollydbgInt 13h  

 


Ollydbg ProSignature  

 

PD: Ostras pedrín, menudo fail@SluggerMaxman tiene esta entrada en su blog desde hace casi 9 meses explicándolo perfectamente.

Usando LinqToTwitter para @MeriDeluxe y @MeriConsolas

Hoy revisando el "log" de @MeriDeluxe y @Mericonsolas he visto que a partir de las 00:00 en punto de la noche de hoy miércoles todos los tweets que se intentaban publicar daban un error.

Mirando en la página de desarrolladores de Twitter me he encontrado con esta noticia,  donde básicamente se dice que a partir de hoy la API v1 deja de usarse y se deberá usar la API v1.1

Hasta ahora estaba usando Twitterizer (repositorio de git hub aquí) que encapsulaba toda la REST API v1 en una librería para ser usada desde C#/VB.NET sin excesivos problemas (vamos, ningún problema).

Efectivamente, comprobando el código ‘in situ’ cuando se intentaba crear un nuevo tweet la respuesta origina un error indicando que la API v1 ya no esta soportada y que se migre a la API v1.1

Buscando una solución rápida y que no me implicase demasiados cambios en el código me he puesto a trastear con linq2twitter (o LINQtoTwitter como queráis) que al igual de Twitterizer es una implementación de la API v1.1 para C#/VB.NET

La página de la descarga está aquí (vía codeplex) 

También podeís instalar la librería vía NuGet desde el propio Visual Studio con el comando:

install-package linqtotwitter 

En ambos casos, ya bien se descargáis la libreria y agregáis la referencia a la dll correspondiente o lo hacéis via NuGet la utilización es bastante simple.

Solo un apunte que me llevo de cabeza un par de minutos, que ahora es explicaré muy rápidamente.

Básicamente lo que hay que hacer para que los bots publiquen los tweets, es crear una autenticación de tipo SingleUserAuthorizer.

Una vez creada la autorización se crea un TwitterContext y con el método UpdateStatus podremos publicar los tweets: 

 

Si hay algún error (autenicación incorrecta, tweet demasiado largo, límite excedido, etc.) saltará la Exception y podremos tomar las ‘contramedidas’ oportunas.

Como véis es bastante simple de usar, casí igual que Twitterizer.

Bueno, el caso es que en la autenticación AccessToken es en realidad lo que en la página de desarrollo es el valor de AccessTokenSecret, no el "AccessToken"

Me explico, desde la página de desarrolladores de Twitter, accedes a la página de tu aplicación, donde tienes los tokens de autenticación:

Yo estaba usando el valor de Acess token en el parámetro de AccessToken y el valor de Access token secret en el parámetro OAuthToken.

Esto es incorrecto. Debe usarse el valor de Access token para el parámetro OAuthToken y el valor de Access token secret en el parámetro de AccessToken.

 

Saludos.
mov eax,ollydbgInt 13h  


Ollydbg ProSignature 

AvatarBmp. La INutilidad que convierte cualquier archivo en una foto

Hola. Hoy os traigo una nueva inutilidad para añadir a mi lista de inutilidades 😀

En esta ocasión estamos hablando de AvatarBmp

¿Qué es AvatarBmp?

AvatarBmp es una herramienta que nos permitirá convertir cualquier archivo, ya bien sea un programa, un mp3, una hoja de Excel, o lo que sea en una "foto". Esa "foto" (archivo *.png) la podremos abrir con el Paint, colgarla en internet, enviarla por e-mail, Güasap, etc.

Esa "foto" la podremos volver a convertir en el archivo original:  

 

 

Podremos seleccionar varios archivos a la vez y "soltarlos" en los botones, tanto para "codificarlos" (generar la foto) como para "descodificarlos" (volver a recupear el archivo original)

Así por ejemplo, si tomamos esta foto y la "codificamos":


(Haz click para agrandar)

Lo que obtendremos será la siguiente imagen:

 

 

Sí, aunque parezca mentira ahí dentro está la adorable Alicia.

Si ahora hacemos el paso contrario, y soltamos ese "amasijo" de pixels y lo descodificamos obtendremos de nuevo la imagen de Alicia. Fácil, simple, rápido, pero sobre todo inútil X-D X-D X-D 

Aquí os dejo un vídeo donde se muestra que no solo se puede hacer con imágenes, sirve para cualquier tipo de fichero, sea un ejecutable, un zip, un rar….lo que sea.  

 

Saludos.
mov eax,ollydbgInt 13h  

Descargar AvatarBmp (compatible 32 y 64 bits)
(86 KB .NET Framework 4) 


Descargar código fuente AvatarBmp
(173 KB. Visual Studio 2010  / .NET Framework 4 / C#) 

 

Serás $%&##@!!! 🙂

 


Ollydbg ProSignature 

.NET Tutorial 60: Como crear un servicio web y usarlo desde Windows Phone

Hace un par de días Btc me comentaba sobre la posibilidad de que una aplicación de Windows Phone se comunicase con una base de datos de SQL que estaba hospedada en un hosting.

Realizar este tipo de tareas es relativamente sencillo usando servicios web y WCF (Windows Communication Foundation).

El ejemplo que os mostraré hoy se divide en 3 proyectos:

1) El proyecto que accede a la base de datos. Este proyecto será una dll

2) El servicio web basado en WCF que permitirá a otras aplicaciones acceder a la base de datos. Este servicio tendrá como referencia la dll de 1) y se hospedará en un hosting

3) Aplicación de ejemplo, en este caso una aplicación de Windows Phone desde la cual se podrá "manipular" la base de datos mediante el servicio web de 2)

 

Paso previo. Crear la base de datos/tabla

Lo primero que vamos a crear es una base de datos en nuestro servidor, en este caso SQL Server. En nuestro ejemplo crearemos la siguiente tabla:

 

El campo id es un campo autonumérico.

La idea es tener una tabla de "puntuaciones" que se podrá actualizar desde una aplicación de Windows Phone, utilizando para ello dos cosas:

1) La tarifa de datos de nuestro operador móvil

2) El servicio web que veremos a continuación.

Paso 1. Crear librería que accede a la base de datos

En este primer tutorial, veremos únicamente como insertar un nuevo registro en la base de datos. En posteriores tutoriales veremos como consultar la lista de puntuaciones para mostrarla en el móvil.

Pues bien, abrimos Visual Studio  y seleccionamos que queremos realizar un proyecto de biblioteca de clases:

El código de nuestra clase solo tendrá una función, a la que hemos llamado InsertarHIScore. La clase la he llamado HiScoreDAL. El código completo de la clase es este:

 

A esta función se le pasa el nombre del jugador y la puntuación y lo que devuelve es el ID dentro de nuestra base de datos una vez se ha realizado la insercción del registro.

Como se observa, se está llamando a otra clase, llamada DALCore, que es la encargada de acceder realmente a la base de datos. 

Esta clase es la que tiene implementados los métodos que crean (Insert), actualizan (Update), borran (Delete) o seleccionan (Select) los registros de la base de datos.

El código completo de la clase DALCore lo podéis ver aquí 

Como véis en el código, básicamente lo único que hay es una funcón que inserta el un registro en la base de datos y recupera el ID de dicha insercción:

 

Compilamos la librería y obtenemos una dll que usaremos a continuación.

 

Paso 2. Crear servicio web basado en WCF

Ya bien sea dentro de la solución anterior o como solución nueva, ahora creamos un proyecto de tipo Aplicación de servicio web:

Una vez creado este nuevo proyecto, lo primero que deberemos hacer es añadir la referencia a la dll que creamos en el punto 1). Para ello, botón derecho sobre el proyecto y seleccionamos agregar referencia. 

Bien, la plantilla de "Aplicación de servicios WCF" nos genera un interfaz (IService1.cs) con unos métodos de ejemplo y una clase (Service1.svc) con la implementación de dicha interfaz

En nuestro caso borraremos los métodos de ejemplo del interfaz del archivo IService1.cs y dejaremos únicamente este código:

 

Ahora en la clase del servicio Service1.svc implementaremos el interfaz de esta forma:
(Nota: en la clase, acordaros de hacer referencia a la dll del punto 1) ya bien sea con un using (C#) o con un Imports (VB.NET)

Bien, el servicio lo tenemos ya casi listo pero falta modificar un par de cosas.

Si accedemos al archivo Web.config del servicio veremos que tenemos una sección denominada   <system.serviceModel> donde se definen las características del servicio:

En mi caso particular, voy a cambiar el "binding" que por defecto es WsHttpBinding por basicHttpBindig. Para ello modificamos está linea en el Web.config:

<endpoint address="" binding="WsHttpBinding" contract="WCFSrvHIScores.IService1"> 

y la cambiaremos por esta:  

<endpoint address="" binding="basicHttpBinding" contract="WCFSrvHIScores.IService1"> 

Además, tengo que añadir toda esta sección dentro de <system.serviceModel> ya que sino mi hostsing no admite el servicio:

<serviceHostingEnvironment>
<baseAddressPrefixFilters>
<add prefix="http://www.midireccion.com/hiscores:8000"/>
</baseAddressPrefixFilters>
</serviceHostingEnvironment> 

Con lo que al final el archivo Web.config tiene este aspecto en lo referente a la sección <system.serviceModel>:

 

Compilamos el servicio y lo subimos a nuestro hosting. Ya estamos listos para el último paso.

 

Paso 3. Crear aplicación que utilice el servicio web

Una vez que ya tenemos nuestro servicio web en marcha, es hora de utilizarlo. Para ello vamos a realizar una aplicación de Windows Phone que básicamente permitirá insertar una nueva puntuación en la base de datos.

Básicamente lo que tenemos son un par de textbox, unos textblocks y un botón.

El mecanismo es el siguiente: Se introduce el nombre y la puntuación en los textbox y al pulsar en el botón se guarda esta información en la base de datos. 

El XAML completo del grid esta aquí.

Pues bien, una vez que tenemos el diseño, lo que deberemos hacer es agregar una referencia de servicio.

Pondremos la dirección de nuestro servicio, pulsaremos en Ir y al cabo de unos segundos veremos lo siguiente: 

 

Como se observa, se ha recuperado la función de definimos en nuestra clase original, InsertarHIScore

En nuestro código básicamente lo que tenemos que hacer es esto:

ServiceReference1.Service1Client mHIScore = new ServiceReference1.Service1Client();

mHIScore.InsertarHIScoreCompleted += new EventHandler<ServiceReference1.InsertarHIScoreCompletedEventArgs>(mHIScore_InsertarHIScoreCompleted);

mHIScore.InsertarHIScoreAsync(TxtNombre.Text.Trim(), Int32.Parse(TxtScore.Text)); 

 

Vemos si funciona el "asunto". Lanzamos la depuración para cargar el emulador de Windows Phone:

Pulsamos en guardar los datos y vemos:

efectivamente, se informa que se ha guardado el registro en la base de datos y que el ID devuelto es 1

Vamos a comprobarlo usando el MSQL Management Studio:

y voilá, efectivamente, el registro se ha creado en la base de datos.

La base de datos está en un servidor en California (EE.UU) mientras que el teléfono está en medio del monte y se ha usado la conexión de datos móviles para insertar dicho registro en la base de datos. No está mal el invento 😀

 

Saludos.
mov eax,ollydbgInt 13h

 

Código completo ejemplo Windows Phone C# aquí
Código completo ejemplo Windows Phone VB.NET aquí.

 


Ollydbg ProSignature 

@MeriBlogs: El ‘bot’ de Twitter que tuitea todas las entradas nuevas de Gamefilia

 

Siguiendo el consejo de algunos usuarios de gamefila (ver aquí) he modificado ligeramente el código de @MeriDeLuxe para incluir las nuevas entradas de gamefilia.

Aquí (foro Comunicados y sugerencias) explico algo más sobre el ‘bot’ 

Espero que os sea de utilidad 🙂

 

Saludos.
mov eax,ollydbgInt 13h  


Ollydbg ProSignature