Una sinfonía en C#

Nueva casa

2011-08-10T23:05:00.001-03:00

Este es el último post en este lugar, a partir de ahora me mudo a un hosting propio sobre una plataforma .net, la nueva dirección del blog es esta.

Todo lo que está acá quedará y lo iré llevando a la nueva casa, gracias Blogger por estos años de darme espacio y gracias a todos los que siguen este blog. Nos vemos en la nueva casa.

Saludos, Leonardo.

VAN sobre conceptos HTTP y Fiddler web debugger

2011-07-24T23:01:00.004-03:00

El pasado sábado 23 de Julio tuve nuevamente el gusto de dar una VAN para la comunidad de Alt.Net hispano, la misma se trató sobre HTTP y Fiddler.

Conceptos básicos de HTTP

En la VAN hablé las cosas que yo creo indispensables que hay que conocer sobre HTTP si nos dedicamos al desarrollo web, su naturaleza, su principales características y limitaciones.

Paralelamante al desarrollo de los temas fui mostrando Fiddler y cómo se puede usar como herramienta para visualizar HTTP, manipularlo y demás.

Fiddler

Finalmente fui mostrando las bondades de esta herramienta y cómo nos puede ayudar de inspeccionar y simular situaciones, cambiar datos, filtrar, hicimos scripts y hasta un plug-in con C#.

Muchas gracias

No tengo más que agradecer a los patrocinadores por los proveer todo lo necesario para la realización de las reuniones y por los regalos que siempre se sortean al final, no quiero dejar de nombrar a Jorge Gamba, el motor de esta comunidad, la pasé muy bien dando la VAN a pesar que siempre algún ejemplo no funciona :-)

El material

Dejo la presentación que utilicé durante la VAN “HTTP las ruedas de la web”, pronto estará la grabación disponible en el sitio de Alt.Net hispano.

El video

Ya está el video disponible

Unable to display content. Adobe Flash is required.

Hasta la próxima, Leonardo.

HTTP un estado aparente, cookies y caché

2011-04-23T21:28:00.002-03:00

En el post anterior dije medio al pasar que HTTP no tiene estado, esto quiere decir que cada transacción es única, no sigue una secuencia y no hay relación entre ellas, esto es a nivel protocolo, o sea que HTTP no provee mecanismos para mantener la sesión “out-of-the-box”, si bien en la web que conocemos podemos entrar a Facebook, ingresar nuestros datos y seguir “logeados”, una clara demostración de que Facebook mantiene el “estado” porque recuerda que ya nos “loegamos” (estoy muy comillero).

Qué son las cookies o sea las galletitas

Técnicamente una cookie es un fragmento de información que se almacena del lado del cliente. Dentro de los muchos headers (encabezados) que podemos ver en una respuesta HTTP hay uno de ellos que sirven para controlar las cookies, la cosa es asi:

Escenario A:
- El servidor indica el cliente que debe guardar una cookie con un nombre y valor determinado.
- El cliente la guarda localmente (de manera segura).
- Con cada nueva petición HTTP el mismo host el cliente envía esa cookie ignorando para qué la necesita el servidor.
Escenario B:
- Desde javascript se genera un cookie (lado del cliente).
- La información se guarda localmente.
- Sólamante es visible desde el ámbito que se creó la cookie (idealmente).
- El servidor desconoce todo esto.

Para mantener el estado usamos cookies

Vamos a concentarnos en el escenario A que es el que permite el funcionamiento del estado sobre HTTP, para eso un dibujito:

Sencillo, en cierto momento que hacemos una petición HTTP al servidor nos response con el header set-cookie, el navegador guarda localmente el nombre y valor de esa cookie y lo envía simpre en cada nueva petición al servidor.

Ejemplo real

Vamos a ver con Fiddler qué pasa con las cookies cuando entramos a un sitio cualquiera. Vamor a www.bing.com

simplemente escribimos la dirección en la barra del navegador (Firefox en este caso) y vemos que se generan 15 peticiones….vamos a analizarlo.

En la primera petición nos responde 200 OK y ocho headers set-cookie, quién sabe para qué, pero Bing los usa para algo, en el contenido del primer mensaje está el HTML de la página solicitada. Nuestro navegador va a recordar todas estas cookies y enviarlas con cada petición nueva al host.

Vamos a analizar la segunda petición:

Y como era de esperar el navegador envía todas las mismas ocho cookies que le indicó el servidor en la respuesta anterior.

Por qué se generaron quince peticiones si hicimos nada más que una?

La respuesta es simple, el HTML de Bing hace referencia a muchos otros recursos también localizados en internet, por ejemplo las imágenes, los archivos de script, las hojas de estilo, etc. el navegador genera todas estas peticiones a medida que analiza el HTML y determina que necesitas los recursos.

Cuando las cosas se “Cachean”

Vamos a ver qué pasa si repetimos la petición original:

Si presionamos F5 y recargamos la misma págna vemos en Fiddler que muchos recursos tiene un ícono con forma de disco, esto quiere decir que el navegador los recuperó del disco local y no los volvió a pedir para optimizar tiempos de respuesta, a esto se le llama caché. O sea el navegador recuerda que ya pedimos ese recurso (por la URL) y lo trae del disco para que sea más rápido, esto pasa mucho con imágenes pero puede pasar con todo, si hacemos Ctrl + F5 obligamos a Firefox a que pida todo de nuevo ignorando el caché.

Podemos desde el servidor obligar a que siempre se pida el recurso sin usar el cache?

Sí, podemos, desde el servidor agregamos el header Cache-Control, por ejemplo con el modificador max-age podemos indicar cuál es el máximo tiempo en segundos que el navegador debe mantener un recurso, en el caso de Bing este header estaba presente en la página por defecto, es por ese que el navegador volvió a pedir el recurso y no lo trajo del cache como los siguientes.

El estado y las cookies

Todo esto era para explicar cómo se puede mantener el estado sobre HTTP, el funcionamiento más simple es utilizar una cookies para que el navegador la envíe siempre y entonces identificamos que se trata del mismo cliente, sería así:

El cliente se conecta
El cliente se logea correctamente
El servidor le dice que guarde la cookie “session_id” con un valor generado único para ese cliente
El navegador guarda la cookie con dicho valor y la envía con cada petición
El servidor revisa siempre el valor de esa cookie e identifica el cliente que se acaba de logear

Es un mecanismo sencillo, pero efectivo, vamos a verlo en funcionamiento.

Un ejemplo sencillo de ver es el modo en que ASP.NET mantiene la sesión, la cookie que usa se llama….asp.net_session y se ve más o menos así:

Si las cookies son tan importantes para la sesión, cómo las borro?

No se borran, se hacen expirar, se agrega detrás de la información de la cookie la expiración, la forma más simple es poner una fecha en el pasado para que el navegador detecte que le llegó la hora y la borre. Esto se logra agregando detrás del nombre y valor de la cookies el atributo expires, por ejemplo:

Set-Cookie: lastlogin=1254773024; expires=Mon, 02-Nov-2009 20:12:04 GMT

Entonces cuando un sitio nos da la opción de mantenernos logeados para siempre en parte hace que esa (o esas) cookies que nos identifican no expiren nunca.

Modificando el web server para comprobar el uso de las cookies

Vamos a agregar una pequeña lógica para probar que el navegador va a recibir la orden de guardar una cookies y después va a enviarla siempre, finalmente vamos a forzarlo a hacerla expirar y no enviarla más, el código modificado queda así:

Simple, en la primera petición se hace set-cookie (con la instrucción de ASP.NET Cookies.Add) y en la tercera obligamos a que la borre, indicando para esa cookie una fecha de expiración en el pasado. Probemos la primera petición y vemos qué dice Fiddler.

Joya, vemos que nuestro servidor envía el header esperado, vamos a hacer una petición a otra página en el mismo sitio para comprobar si el navegador envía la cookie.

Adicionalmente envíamos la indicación para que expire la cookie, entonces en la siguiente petición no debería ser envíada, vamos a ver….

Notable, funcionó, con esto comprobamos el funcionamiento de las cookies y el comportamiento del navegador.

Hasta la próxima.

Introducción a HTTP, las ruedas de la web

2011-04-16T10:23:00.001-03:00

Voy a contar un poco de qué se trata HTTP, el protocolo que da vida a la web.

HTTP es un protocolo. Técnicamente es un protocolo de aplicación (según el modelo OSI) pero en web se utiliza como transporte, es decir para transportar lo que realmente nos importa: el contenido, el HTML, XML, PDF, Zip, etc.

Algunas características de HTTP

A cada comunicación se la llama transacción HTTP.
Todas las transacciones comienzan del lado del cliente (en nuestro caso un navegador WEB).
Es, básicamente, texto.
Tiene dos secciones: una encabezado y un cuerpo.
Se basa en verbos, que indican qué tipo de operación se desea realizar con la petición.
Los verbos más comunes son: GET, POST, DELETE, HEAD, PUT.
Las repuestas tiene un código de estado (STATUS CODE) qué nos indica qué pasó con nuestro request.
Es un protocolo sin estado, es decir, no existe secuencialidad entre transacciones.

Anatomía de una petición HTTP

GET http://www.bing.com HTTP/1.1

Esta es la petición más básica que podemos hacer para solicitar un recurso (digo recurso porque no sólo pedimos páginas sino imágenes, script, fuentes, etc), vamos a analizarla.

Utiliza el verbo GET, es que vamos a utilizar en general para solicitar un recurso.
http://www.bing.com es el nombre del recurso que queremos recuperar, se utiliza el protocolo URL para esto, el nombre del recuros tiene que ser único.
Por último la versión del protocolo

ok, esto está muy bien, pero no nos quedemos con mis dichos, vamos a verificarlo.

Armando nuestra primer petición HTTP a mano

Vamos a hacer el papel de navegador Web, para eso vamos a ejecutar el Fiddler e ir a la ventana que dice "Request Builder", dentro de ella a la opción "Raw" (que quiere decir "a lo macho") y escribimos exáctamente el request que acabamos a analizar, pero no nos olvidemos de hacer dos veces ENTER o sea, dejar una línea en blanco (por definición antes del cuerpo hay que dejarla) .

Hacemos "execute" y..mágia (ignoremos el cartel que pone Fiddler sobre violación de protocolo por falta del header “host” por el momento). Bing nos responde!

En la columna de la derecha vemos las transacciones y en la izquierda seleccionado “Insepections” y luego “Raw” podemos ver arriba el requerimiento que armamos y debajo la respuesta, vamos a analizar lo más importante (por ahora) de la respuesta.

Analizando la respuesta

De todo lo que vamos a ver en la respuesta en este caso nos vamos a concentrar en lo que nos dicen los siguientes datos:

HTTP /1.1 200 OK
Content-Type: text/html

estos son los datos más importantes (de momento) dentro de una respuesta.

HTTP /1.1 la versión del protocolo

200 OK el código de estado y la descripción, en este caso 200 significa que la petición fue exitosa

Content-Type: text/html el tipo de contenido, ya que HTTP transporta texto necesitamos sabes la naturaleza de los datos para saber cómo interpretarlos, por ejemplo si el contenido fuese una imagen JPG el encabezado sería

Content-Type: image/jpg

a la codificación que se utiliza en el encabezado Content-Type se la conoce como MIME type, hay uno para cada tipo de contenido, notemos que el navegador se va a basar en él para saber qué hacer con el contenido (la extensión del recurso se ignora), en caso de ser un contenido que puede manipular (por ejemplo text/html) lo hará, sino buscará un programa relacionado para hacerlo, por ejemplo con el MIME Type application/ms-word el navegador sabe que tiene tiene que llamar al MSWord.

Lo que viene después de todos los encabezados y luego de una linea en blanco es la página de Bing, o sea el contenido, en definitiva el recurso que estámos pidiendo.

Armando nuestro propio Web server

Vamos a demostar lo mismo que antes pero jugando el papel de Web server, es decir, desde el navegador vamos a pedir un recurso a un web server hecho por nosotros, manos a la obra.

Haciendo abuso de mis conocimiento de programación hice un web server en 30 líneas que además de despachar archivos nos indica un error 404 si no encuentra algo, vamos a probarlo.

Mágia, de más está decir que tengo un archivo “default.htm” en el directorio “C:\temp\pruebasVS2010\minweb\minweb\files” con ese increíble contenido, pero no seamos confiados, vamos a ver si funciona cuando no existe el recurso

Increíble no? no nos muestra el mensaje que pusimos porque por defecto IE muestra una mensaje “amigable”, probemos con Firefox

Notable, ahora vamos a demostrar que no importa la extension sino que estos navegadores al no enviar nosotros el encabezado “Content-Type” por defecto interpretan HTML, vamos a forzarlos a que llame al lector de PDF configurado en nuestro sistema.

Forzando al navegador a llamar al lectro de PDF

El Content-Type lo vamos a ponder como “application/octet-stream” para indicar que es un archivos binario, y vamos a agregar un header con el nombre del archivo destino para que el sistema operativo llame al lector de PDF configurado.

Hecho esto, no queda más que probarlo, y….

El POST y el GET

Ok, hasta ahora usamos el verbo GET para recuperar contenido, esto está muy bien, pero qué pasa si necesitamos pasar parámetros al servidor para recuperar el contenido, por ejemplo queremos recuperar información de un usuario pero necesitamos indicar de qué usuario, entonces usamos lo que se conoce como “Query String” que no es más que agregar los parámetros al final de la dirección URL y es parte del estándar, sería algo así:

http://localhost/detalleUsuario.aspx?id=1

Donde el “Query string” es todo lo que está después del signo de interrogación, y tiene la forma “nombre=valor” en este caso “id=1”.

Esto está muy bien, entonces por qué si queremos ingresar nuestro usuarios y contraseña por qué no enviarlos como parte del query string? hay varias respuestas para esta pregunta

El largo máximo de la URL total, si bien HTTP no especifica un largo máximo hay varios límites, tal vez lo más importante sea que IE6 limita a 2086 el largo, algunos servidores a 256…en definitiva no vale la pena arriesgarse a superar 256.
Hacerlo por GET implica que la URL + los parámetros van a ser visibles en la barra de navegador.
Se puede guardar en favoritos si es una dirección.
Sintácticamente para enviar datos se tiene que usar POST y no GET

Si bien alguna de estas desventajas pueden ser ventajas dependiendo de lo que querramos hacer, por ejemplo si tenemos un sitio de ventas por internet es interesante que una búsqueda se pueda ver en la barra de naveagación para poder compartirla, por ejemplo los buscadores usan formularios con el verbo GET para que podamos guardar la búsqueda.

Hay un lugar en donde podemos enviar toda la información que querramos y además no es visible para el usuario (no se ve en la barra de navegación) y es mediante el verbo POST ya que los datos los podemos poner en el cuerpo del mensaje (si ponemos información en el cuerpo y usamos GET el servidor lo va a ignorar).

“Posteando” datos

Sí, la expresión “voy a postear” viene del verbo POST de HTTP, para postear simplemente hay que cambiar el verbo a POST en el paquete HTTP, el resto es igual, incluso podemos seguir usando query string, desde HTML es necesario utilizar un elemento Form (formulario) para hacer POST, si bien, podemos cambiarlo para que el formulario envíe usando GET (que es el método por defecto de los formularios).

Vamos a hacer un formulario HTML y ver con Fiddler por dónde van los datos

Presionamos “enviar datos” vamos al Fiddler y vemos que los datos del formulario están en el cuerpo del mensaje, los nombres de los elementos se toman de cada atributo “name” de cada elemento dentro del formulario.

Por supuesto que nuestro web server devuelve error 404 porque no existe el recurso “destino.htm”

Leyendo datos de POST desde el web server

Modificamos levemente el código de nuestro web server para leer datos del POST

ejecutamos otra vez default.htm con el formulario y listo, tenemos los datos en la consola!

De esta manera verificamos que los datos vienen en el cuerpo del mensaje cuando usamos el verbo HTTP POST.

Es todo por esta vez. En la próximos post vamos a ver cómo se hace para mantener el estado sobre un protocolo sin estado, qué podemos hacer con los códigos de estado y otras cosas locas, nos leemos.

SharpTestEx extensiones para hacer las pruebas unitarias más alegres

2011-04-05T23:29:00.001-03:00

Cuando hacemos mucha prueba unitaria (Unit Test) nos encontramos a menudo con tareas similares como evaluar si un número está dentro de un rango, si una colección contiene cierta cantidad de ítems, y cosas así para las cuales nuestro amado .NET Framework no está dotado de funciones ya listas para usar “out of the box” sino más bien tenemos que hacer algunos “Helpers” y cosas así para poder probar más felizmente.

SharpTestEx

El amigo Fabio Maulo en el tiempo que le queda siendo el project leader de NHibernate, manteniendo su propio framework para mapeos de NHibernate, ConfORM, trabajar y otras cosas, se hizo un rato y se escribió un conjunto de métodos de extensión para ampliar las funcionalidades del Framework. :)

Básicamente son métodos de extensión que extienden la clase object, con lo cual con agregar la referencia a la única DLL de SharpTestEx ya contamos con toda su potencia, que nos pemite hacer cosas como esta:

Sintáxis fluyente y auto-descriptiva

[TestMethod]
public void TestMethod1()
{
var texto = "mi vieja mula ya no es lo que era";

texto.Should().Contain("mula");
}

Notemos que el objeto texto (que no es más que un string) ahora tiene un método Should() que indica que debería cumplir concierta condición, en este caso se leería

texto debería contener “mula”

bien descriptivo, con esta sintáxis ya está listo el test, si la condición no se cumple SharpTestEx lanza una bonita excepción que además nos dice exáctamente qué pasó, mágico.

Potencia por todos lados

SharpTestEx tiene un arsenal de métodos que nos facilitan la vida cada día, Fabio es un tipo que programa mucho y sabe mucho qué necesita un programador a la hora de probar. Sino miren las estadísticas de Fabio en Ohloh.

public void TestMethod2()
{
var valorBoleano = false;

valorBoleano.Should().Be.False();
}

Otro ejemplo de la rica sintáxis, lo interesante de que el código sea quien describe lo que va a pasar en lugar de agregar un pila de comentarios es que cuando cambiemos el código para que se comporte de otra manera ya tenemos la auto-documentación actualizada, por lo menos en mi experiencia los comentarios si son muchos suelen quedar obsoletos, pero es una opinión personal.

public void TestMethod()
{
var valorNumerico = 110;
valorNumerico.Should().Be.GreaterThanOrEqualTo(100);
}

Otro ejemplo muy claro, el método GreaterThanOrEqualTo nos soluciona unos cuantos problemas si quisiéramos hacerlo a mano.

public void TestMethod()
{
var listaEnteros = new[] { 1, 2, 3 };

    listaEnteros.Should()
        .Not.Be.Null()
        .And.Not.Be.Empty()
        .And.Not.Have.SameSequenceAs(new[] { 3, 2, 1 })
        .And.Have.UniqueValues();

listaEnteros.Should().Contain(2).And.Not.Contain(4);

listaEnteros.Should().Contain(3).And.Not.Have.Count.LessThan(2);
}

Este ejemplo copiado del sitio de Codeplex nos muestra la versatilidad para verificar IEnumerables<T> (colecciones) y que además podemos encadenar validaciones, más que mágico!

Detalles finales

Lo único que me queda decir es que sin duda SharpTestEx es una herramienta que siempre nos va a facilitar las cosas, un detalle es que hay un assembly (DLL) según el framework de Unit Testing que usemos, por ejemplo yo usé MSTest el que viene integrado dentro de Visual Studio y agregué el using al principio de los test para “ver” los métodos de extensión.

using SharpTestsEx;

Nada más, nos vemos la próxima.

Año nuevo, objetivos nuevos

2011-01-04T13:02:00.000-03:00

Comienza un nuevo año y con él vienen las declaraciones de deseos y objetivos, y bueno, acá van los mios:

Nuevo hospedaje para el blog

Muchas veces me preguntaron por qué no pongo Add-Algo en el sitio para ganar un pesos y la respuesta es “porque no es la idea” además todos sabemos que si yo gano $1 Google gana $2, entonces esa reflexión se extiende a “no quiero regalarle plata a Google”, tanto es así que voy a migar este blog en algún momento del año a otra plataforma y otro hosting, posiblemente uno de pago y sobre WordPress.

Escribir un Libro sobre programación usando SCRUM

Muchas veces me llegaron consultas para que recomiende libros sobre programación en .Net y mi respuesta siempre fue la misma “no sé, la verdad es que no conozco ninguno recomendable” pero no me quedé nunca conforme con la respuesta, por lo tanto voy a tomar el toro por las astas y hacerlo yo, como declaración dejo lo único que por ahora tengo claro sobre el libro:

Será en Castellano
Será público
Será sobre .Net
Será sobre C#
Comenzará desde POO, incluyendo conceptos de clases, objetos, interfaces, polimorfísmo, etc.
No tocará temas sobre Winforms
Habrá conceptos web de base, http, html, xml, etc. siempre es mejor comprender lo que pasa
Se hablará de herramientas como Reflector, Fiddler y otras.
Hablará de patrones que yo uso, y no de cosas demasíado poco comunes y que confunden más de lo que aclaran.
Se tocará mucho el temas de test de unidad
Se hablará de mocking y moq.
Se hablará sobre legibildiad de código, comentarios, etc.
Se hablará de frameworks como MVC
Se hablará de Javascript
Se hablará de jQuery

Y mucho más, es ambicioso, pero como si fuera poco lo pienso desarrollar usando SCRUM, de la siguiente manera:

La lista anterior sería un backlog del producto, la visión es la siguiente: “Escribir un libro de programación en .net que toque los temas básicos que muchos libros dan por obvios y abarque los conceptos y herramientas de todos los días”.

El modelo de desarrollo será Scrum con sprint mensuales, por supuesto, el resultado de cada sprint es un entregable.

En fin, es una primera aproximación, me falta definir la fecha de inicio, voy a ir refinando el backlog el cual pronto publicaré de modo público.

Saludos, Leonardo.

El pajarraco Scrumero

2010-10-17T00:09:00.002-03:00

Introducción

El miércoles trece de octubre pasado en el marco de la materia “Arquitectura Web” que tengo el gusto de dictar en la universidad CAECE vivimos una experiencia muy gratificante.

Como parte de una humilde evangelización de metodología ágiles al principio de la cursada se dicta una clase introductoria a SCRUM, mi idea siempre fue hacerlo más práctico entonces envié una pregunta sobre cómo podría hacer una práctica grupal de introducción a la lista de ágiles, como era de esperar recibí muchísimas sugerencias pero además recibí un mail privado de Ingrid Astiz ofreciéndose a venir ella personalmente a hacer el juego del pajarraco obra del gran Alan Cyment.

Después de coordinar unas semanas llegó el día y recibimos a Ingrid en el aula.

La dinámica del juego

Se armaron cinco grupos de alumnos que con una caja de RASTIS cada uno.

Se organizaron planning meetings de 5’, sprints de 10’, reviews de 2’ y retrospectivas de 2’, este ciclo se repitió 3 veces, todos los alumnos participaron con mucho entusiasmo de la actividad y esto quedó reflejado cuando después de terminado el ejercicio hicimos entre todos una retrospectiva sobre la actividad donde surgieron preguntas sobre metodologías ágiles y grupos de trabajo, esta retrospectiva duró más de una hora.

La actividad ayudó mucho a la integración y a la comprensión de la metodología y demuestra que no sólo se puede usar una metodología ágil para desarrollar software, durante la actividad salieron a la superficie los mismos errores y soluciones que en un proyecto real, por supuesto a partir de ahora lo vamos a practicar en cada cursada.

Aspectos sobresalientes:

La autogestión de los equipos, sprint tras sprint se iban encontrando los roles.
El surgimiento de líderes naturales, que van apareciendo según la situación.
Preguntar, dejar de lado supuestos y repreguntar.
Retrospectiva, parar la pelota y pensar qué de hizo mal y qué se puede mejorar.
Le estimación, todos los equipos fueron encontrando su propio ritmo de trabajo después de cada sprint.
La sinergia que surgió naturalmente cuando todos siente el objetivo como propio y se reconocen como iguales.
La integración del grupo.
El diseño emergente, la comprensión del producto incremental.

Agradezco infinitamente a Ingrid por su voluntad y generosidad, a Marcela y Vero por ayudarnos, hasta la próxima.

Introducción a Builds automáticos o “Cómo corno funciona MSBuild”

2010-07-31T13:34:00.001-03:00

En ambientes de desarrollo medianamente profesionales es una práctica muy común contar con Builds automáticos, esto significa que tenemos un mecanismo que por si sólo en algún momento se hace del código fuente de nuestra aplicación, lo compila, corre las pruebas unitarias y publica los resultados. Es una gran idea, por ejemplo, podemos tener configurado para que todas las noches (porque puede ser un proceso muy pesado para hacerlo cuando la gente trabaja) nuestro BuildServer (el servidor donde tenemos configurada toda esta magia) se comunica con el control de código, baja la última versión de todo, compila, corre las pruebas, etc. y nos envía un bonito mail con el resultado.

Básicamente tenemos que poder contar con una herramienta que se encargue de esta automatización, casi que con mucha habilidad podemos hacerlo con el programador de taras de windows y crear tareas que ejecuten los siguientes pasos:

Bajen la última versión del código del repositorio
Compilen todo en Release
Corran las pruebas unitarias
Adicionalmente puede verificar otra cosas como Code coverage o políticas de revisión de código, etc.
Publique los resultados en un lugar de la red
Nos envíen el resultado por mail

La idea detrás de esto

La idea final sería que si trabajamos en un equipo sobre un sistema medianamente complejo asegurarnos que nuestros cambios no rompen cosas que depende de él y viceversa, adicionalmente publique los resultados para que se encuentren disponibles para probarlos, de esta manera todos los días tendríamos la última versión (en desarrollo) lista para ser probada con un nivel de prueba de caja blanca muy bueno (siempre va a depender de nuestras pruebas unitarias) ~~por lo menos sabemos que compila~~.

Herramientas para Builds automáticos

No, no vamos a usar el programador de tareas, pero no por falta de valor sino porque ya existen herramientas que no sólo permiten programar tareas de este tipo, sino que además traen tareas para:

Comunicarse con control de código: TFS, VSS, SVN, Mercurial, etc.
Llamar al compilador
Correr los test unitarios: MSTest, NUnit, MBUnit, etc.
Ejecutar políticas de codecoverage: Visual studio, etc.
Enviar Mails.
Etc.

Otra cosas muy interesante que estas herramientas suelen traer es la posibilidad de ser disparadas por distintos eventos:

En algún momento del día
Un día particular de la semana
Al hacer check-in del código
Al hacer una cantidad de check-ins
etc.

Hay varias aplicaciones para hacer esto, entre las más conocidas (por mí al menos) tenemos:

NAnt: Port del Ant para .NET
CruiseControl
MSBuild

En este post vamos a hablar de MSBuild ya que es el que yo uso y viene con el Visual Studio 2005 en adelante

MSBuild

MSBuild es una aplicación que viene con el framework desde la versión 2.0 y cuando creamos un proyecto en Visual Studio en realidad ese archivos .csprj es un archivo que le dice a MSBuild que compile nuestro proyecto, en resumen, desde Visual Studio 2005 los archivos .csprj son archivos de MSBuild que compilan lo que escribimos en Visual Studio.

Target y Task en MSBuild

Es hora de empezar a jugar con MSBuild, entonces vamos a empezar a jugar con la herramienta para tener claro dos conceptos muy importantes, Targets y Task.

Como se ve en el gráfico, un target es un conjunto de tareas, la tareas es el menor unidad de ejecución, sin embargo no podemos ejecutar una tarea que no se encuentre en un target.

Nuestro primer Build

El archivo de configuración para MSBuild más sencillo sería así:

Sí, es un XML…..el nodo raíz es del tipo Project y apunto al namespace de Microsoft msbuild del 2003 (en mi caso) dentro tiene que existir al menos un elemento, en nuestro caso un Target con un nombre, en nuestro caso “prueba” y listo, como esto no sirve para nada vamos a agregar una tarea a nuestro Target.

Creamos un archivo, por defecto la extensión tiene que ser .target, pero podemos ponerle cualquiera, en mi caso hice un archivo “saludo.xml” y lo dejé en “C:\temp” para ejecutar MSBuild (y casi cualquier herramienta de línea de comandos del framework”) lo mejor es usar la línea de comandos de Visual Studio, que se instala en Tools

Llamamos a la línea de comandos y nos ponemos en el path del archivo que acabamos de crear con el código de arriba, la tarea que agregué es una de las tantas que trae MSBuild incorporadas y sirve para mostrar mensajes por consola, entonces escribimos en la consola:

MSBuild saludos.xml

y magia

Por supuesto que esto no es muy interesante, pero no olvidemos que se puede llamar al compilador de C#, a MSTest, a cualquier exe, a un bat, a TFS y lo mejor de todo es que podemos crear nuestras propias tareas e invocarlas. Tampoco olvidemos que esto que acabamos de hacer puede ser llamado por TFS como parte de un Build disparado por un check-in.

Tip: podemos tener n Targets y ejecutar lo que querramos indicandole a MSBuild con al argumente /t:nombreTarget

Compilando y ejecutando desde MSBuild

Vamos a crear una pequeña aplicación con C#, compilarla y luego invocarla con MSBuild, el código de la aplicación es éste

En el mismo directorio “C:\Temp” cree una clase class.cs con un punto de entrada, que simplemente escribe los parámetros en la consola si los hay, en caso que no los haya escribe “sin elementos” una gran pieza de software si me permiten decirlo, creamos un archivo “compilacion.xml” de este modo:

Como vemos la tarea “Csc” invoca al compilador de C# es una tarea predefinida de MSBuild, le decimos que compile class.cs sin más, luego un mensaje y por último la tarea “Exec” permite ejecutar cualquier ejecutable (o un archivo con un ejecutable asociado como un pdf por ejemplo) si todo sale bien deberíamos ver esto:

Funcionó, la salida de la aplicación al ser una aplicación de consola va directamente a la línea de comandos de Visual Studio.

Parámetros

Muchas veces necesitamos pasar parámetros a las aplicaciones que invocamos, esto es bien sencillo, las pasamos detrás del nombre del ejecutable, así:

Perfecto, algo un poco más interesante sería poder pasar parámetro que vengan de otro lado

Propiedades

Otro de los elementos que pueden estar a nivel de Target (es decir ser hijos directos de Project) es “PropertyGroup” elemento dentro del cual podemos definir propiedades, es decir, pares clave-valor que podemos definir a nuestro gusto y utilizarlo dentro del proyecto del MSBuild, por ejemplo:

Vemos que hacemos referencia a las propiedades dentro de la tarea Exec haciendo $(nombrePropiedad), como resultado vemos esto:

Mágico.

Condiciones

Otra cosa interesante es la posibilidad de que diferentes cosas ocurran a partir de condiciones, por ejemplo

En este caso indicamos que si la propiedad Configuration tiene el valor “debug” ejecute la segunda tarea de Csc.

Tip: La propiedad Configuration es una propiedad reservada de MSBuild

Ahora sí, algo un poco más real

Ahora vamos a ver un ejemplo más completo de un escenario real, basado en el post de nuestro gran amigo José Romanielo en su blog “Integración Continua en .net y basta de cháchara”

La idea es tener una pequeña configuración que compile nuestro proyecto y ejecute los test. Vamos a hacerlo de a poco.

Tip. Podemos importar proyectos de MSBuild con el tag import, una escenario común es importar tareas comunes que se instalan en nuestra máquina al instalar Visual Studio

Vamos a crear una librería de clases con una calculadora (tuve un ataque de originalidad) y otro proyecto dentro de la misma solución que compile ambos, corra los test con Nunit y publique los resultados, vamos de a poco.

Presentamos el código de la aplicación:

El archivo de configuración para el Build sería el siguiente:

En “PropertyGrupo definimos paths de la solución, de salida y donde se encuentra NUnit.

El Target “All” es necesario para invocar a los otros dos, esto lo indicamos en la propiedad “DependsOnTargets” sino MSBuild ejecutaría el primer target y se detendría.

MSBuild task es interesante porque nos permite invocar a una solución y ejecutar todo lo que está dentro, si pensamos un poco nos damos cuenta que la solución invoca csproj que son también archivos de MSBuild!! un detalle piola es la posibilidad de modificar Properties, en este caso modificamos la propiedad OutputPath para que los proyectos envíen el resultado a el directorio que nos interesa.

Ejecutamos y todo funciona según lo esperado.

Mágico, faltaría indicar a NUnit que publique los resultados, esto es simplemente pasarle un parámetro adicional, así:

Y listo.

Qué nos faltaría?

Como dije al principio es interesante que esto se ejecute automáticamente cuando hacemos check-in o en ciertos momentos del día, si tenemos TFS podemos instalar el TFSBuildAgent que se encarga de hacer esto sino CruiseControl o algo similar.

Otras cosas para ver es dar una vuelta por MSBuild Extension Pack donde hay una gran referencia y muchas tareas comunes, también invetigar un poco .target que vienen por defecto en los archivos csproj.

Saludos, Leonardo.

Referencias

MSBuild References

MSBuild Extension Pack

Cruise Control

Vale: Framework de validación de la comunidad Alt.Net Hispano

2010-07-05T17:38:00.001-03:00

Hace algunos días nomás la comunidad de Alt.Net Hispano ha dado vida a un nuevo proyecto de código abierto llamado Vale.

A partir de la iniciativa de Fabio Maulo y el apoyo de Jorge Gamba, José Romaniello y otros se decidió hacer un framework de validación que sirva de puerta para que más gente se acerque al código abierto.

Metodología de desarrollo

Una de las grandes cosas que tiene este proyecto es que el desarrollo se hace en vivo…si si, cada tanto (por ahora semanalmente pero no hay un periodo fijo) a través de un Alt.Net Café alguien (Fabio generalmente) va programando en vivo el desarrollo, gracias a la magia de internet todos pueden opinar durante el desarrollo usando TDD.

Se se realizaron dos de estos encuentros y el framework está casi para usarlo, dejo el link del primero

Primer Alt.Net Café “Vale: desarrollando un framework desde cero con TDD”

Hablemos del framework, validación no - intrusiva

Algunos comentarios de Vale, en comparación con otros frameworks de validación como EntLib VAP, el primero que me viene a la mente es la validación no intrusiva, es decir en lugar de tener una clase Person así:

public class Person
{
    public string Name { get; set; }
    public string Surname { get; set; }
    public DateTime Birthday { get; set; }
}

y para validar agregar atributos en las propiedades así:

{
    [RequiredValidator]
    public string Name { get; set; }
    [StringLenghtValidator(20)]
    public string Surname    { get; set; }
    [TypeValidator(typeof(DateTime)]
    public DateTime Birthday { get; set; }
}

un método que deja “pegadas” las validaciones al modelo, con Vale hacemos esto:

IValidator validator = new Validator();
validator.Register<Person>(p => validator.StringIsRequired("Name", p.Name));
validator.Register<Person>(p => validator.StringIsRequired("Surname", p.Surname));
validator.Register<Person>(p => validator.DateIsInThePast("Birthday", p.Birthday));

La interface IValidator es tiene un método Register<T> que permite registrar validaciones sobre un tipo en particular sin que dicho tipo no se modifique, interesante.

Analizando la implementación:

Como dije antes el desarrollo se hizo on-line y se fueron tomando decisiones allí mismo, vamos a recorrer el código de esta versión y a contar un poco el por qué de cada parte.

La interface IValidator

public interface IValidator
{
    void Register<T>(Func<T, string> assert);
    IEnumerable<string> GetInvalidMessages(object entity);
}

Básicamente la idea de esta interface es permitir a través del método Register<T> registrar validaciones para un tipo en particular, y con IEnumerable<T> GetInvalidMessages recuperar los errores, la utilización es la siguiente:

IValidator validator = new Validator();
validator.Register<Person>(p => validator.StringIsRequired("Name", p.Name));

Para todos las entidades del tipo Person que quisiéramos validar se aplicarán todas las reglas que hayamos registrado de este modo.

Actualmente no existe la posibilidad de tener diferentes políticas o reglas de validación para hacer algo así:

IValidator validator = new Validator();
validator.Register<Person>(p => validator.StringIsRequired("Name", p.Name), "default");

var invalidMessages = validator.GetInvalidMessages(person, "default");

Por el momento ya subí el Issue a codeplex, veremos si se implementa en alguna versión, o no, lo decidirá la comunidad.

El otro método que tiene por ahora la interface es IEnumerable<T> GetInvalidMessage, que básicamente aplica las validaciones y recupera los errores.

La implementación interna

Pongo es código de Validator en su primer versión (quité un par de líneas para simplificar) comentadas para su comprensión

public class Validator : IValidator
{
    /// <summary>
    /// Lista de (tipo, lista) de validaciones para el tipo, 
    /// el tipo es la clave del diccionario
    /// </summary>
    Dictionary<Type, List<Func<object, string>>> validatorsHolder = 
        new Dictionary<Type, List<Func<object, string>>>();

    /// <summary>
    /// Permite registrar validaciones para un tipo, si ya existen validaciones 
    /// para el tipo las agrega sino crea el grupo de validaciones.
    /// Al permitir que los validadores sean Func&lt;T,string&gt; se puede hacer
    /// validator.Register&lt;Person&gt;(p => validator.StringIsRequired("Name value")
    /// llamar al Func&lt;T,string&gt; y recuperar el string como resultado
    /// de la ejecución de la Func sobre T
    /// </summary>
    /// <typeparam name="T">El tipo al que se aplican las validaciones</typeparam>
    /// <param name="assert">La validación</param>
    public void Register<T>(Func<T, string> assert)
    {
        //recupera el tipo al que se aplicaran las validaciones
        var objType = typeof(T);

        //verifica si ya existe la lista de validaciones para T, sino la crea
        List<Func<object, string>> actions;
        if (!validatorsHolder.TryGetValue(objType, out actions))
        {
            actions = new List<Func<object, string>>();
        }

        //agrega la nueva validación a la lista de validaciones
        actions.Add(x => assert((T)x));

        //agrega la lista al holder de todas las validaciones
        validatorsHolder[objType] = actions;
    }

    /// <summary>
    /// Ejecuta las validaciones sobre la instancia y retorna los mensajes de error
    /// </summary>
    /// <param name="entity">La entidad sobre la que se aplicarán las validaciones</param>
    /// <returns>El listado de error, string[0] si no existen</returns>
    public IEnumerable<string> GetInvalidMessages(object entity)
    {

        //recupera el tipo del objeto a validar
        var objType = entity.GetType();

        
        List<Func<object, string>> actions;
        //si existe una lista de validaciones para T se ejecutan
        if (validatorsHolder.TryGetValue(objType, out actions))
        {
            //se llama a todas las validaciones dentro de actions 
            //(las validaciones para T dentro del holder)
            //ejecuta las action que no tienen mensaje vacio
            return actions.Select(action => action(entity))
                .Where(message => !string.Empty.Equals(message));
        }
        return new string[0];
    }

Como se puede ver es muy sencillo, un IDictionary que tiene como clave de cada valor el tipo (el tipo que queremos validar) y como valor una lista de validadores, que en este caso son Func<T,string> donde T es el mismo tipo que queremos validar y string el mensaje de error.

Entonces un validador no sería más que un simple método que acepte T y retorne un string en caso de error, la implementación más sencilla sería:

public class Validadores
{
    public string StringIsRequired(string value)
    {
        if (string.IsNullOrEmpty(value))
        {
            return string.Format("field is required.");
        }
        return string.Empty;
    }

}

Para usarlo así:

IValidator validator = new Validator();
validator.Register<Person>(p => new Validadores().StringIsRequired(p.Name));

var person = new Person { Name = null, Surname = null, Birthday = DateTime.Today };
var invalidMessages = validator.GetInvalidMessages(person);

Para mayor comodidad se implementaron como Extension Methods para IValidator en la clase estática CommonValidator y el uso es el siguiente:

IValidator validator = new Validator();
validator.Register<Person>(p => validator.StringIsRequired("Name", p.Name));
validator.Register<Person>(p => validator.StringIsRequired("Surname", p.Surname));
validator.Register<Person>(p => validator.DateIsInThePast("Birthday", p.Birthday));

var person = new Person { Name = null, Surname = null, Birthday = DateTime.Today };
var invalidMessages = validator.GetInvalidMessages(person);

Mágico por todos lados, nos vemos la próxima.

Links

Proyecto Vale en Codeplex

Twitter de la comunidad Alt.Net Hispano

Lista de correo de Alt.Net Hispano

Cómo hacer llamas AJAX a otros sitios, o qué es JSONP

2010-06-27T13:26:00.001-03:00

Una de las limitaciones que tiene el objeto XMLHTTPRequest (el objeto que da vida a AJAX) es no poder hacer llamadas a URLs fuera de nuestro dominio, es decir, si desde mi sitio quisiera traer las fotos de Flikr con el tag “dog” llamando a la URL http://api.flickr.com/services/feeds/photos_public.gne?tags=dog con el siguiente código

<html>
<head>
<script src="http://code.jquery.com/jquery-latest.min.js"></script>
<script type="text/javascript">
    $(function()
    {
        $("#boton").click(ajax);
    });

    function ajax()
    {
        var url = "http://api.flickr.com/services/feeds/photos_public.gne?tags=dog";
        $.get(url, null, function(data)
        {
            $("#contenedor").html(data);
        });
    }
    </script>
</head>
<body>
    <div id="contenedor" />
    <input type="button" id="boton" value="probar" />
</body>
</html>

Utilizando jQuery hacemos un simple llamada AJAX y no pasa nada, vemos qué nos dice Fiddler

Vemos que la llamada se hace y los datos vienen pero no pasa nada, vamos al Firebug y vemos algo interesante

Firebug no nos muestra datos, esto es porque no se permiten llamadas a otro dominio con XMLHTTPRequest, he aquí el problema.

JSONP la solución

Una cosa que si permiten los navegadores es cargar recursos desde otros dominios, es decir, nada impide que un elemento <img> tenga su src apuntando a un recurso externo, es más, un <script> puede tener su origen en un dominio externo como en el ejemplo anterior que cargamos el archivo de jQuery desde http://code.jquery.com/jquery-latest.min.js y funciona perfectamente, otra cosa que podemos hacer es crear dinámicamente elementos <script>, entonces imaginemos que el recurso externo que queremos cargar en lugar de traernos solamente un conjunto de datos nos trae una llamada a un función dentro de nuestro código? para ser más claros, imaginemos que queremos llamar una URL que nos trae el valor “hola mundo”, no podemos recuperarlo con AJAX por la limitación que comentamos, pero qué pasaría si en lugar de traer “hola mundo” no trae código Javascript que incluya una llamada a una función?, así: MiFuncion(“hola mundo) y generamos dinámicamente un tag <script> que apunta a la URL esa, es decir, hacemos esto:

function jsonp()
{
var url = "http://hostRemoto/datos";
$("<script>").attr("src",url).appendTo("head");
}

function MiFuncion(data)
{
alert(data);
}

y http://hostRemot/datos retorna MiFuncion(“hola mundo”)

Entonces conseguimos utilizar datos generados en hostRemoto, a esto se le llama JSONP JSON+Padding, lo interesante de esta técnica es que muchas API públicas la implementan, la de Yahoo, Flikr, Twitter, etc. En general la forma de utilizarlas es indicando como parámetro el nombre de nuestra función, es decir

http://hostRemoto/datos?callback=MiFuncion

Con eso le indicamos a hostRemoto que agregue delante de los datos que retorna una llamada a MiFuncion, en el caso de Flickr es así

http://api.flickr.com/services/feeds/photos_public.gne?tags=dog&format=json&jsoncallback=MiFuncion

Entonces, un ejemplos completo de una implementación de JSONP llamando a Flickr sería así:

<html>
<head>
<script src="http://code.jquery.com/jquery-latest.min.js"></script>
<script type="text/javascript">
    $(function()
    {
        $("#boton").click(jsonp);
    });
    function jsonp()
    {
        var url = "http://api.flickr.com/services/feeds/photos_public.gne?tags=dog&format=json&jsoncallback=MiFuncion";
        $("<script>").attr("src",url).appendTo("head");
    }
    function MiFuncion(data)
    {
        $.each(data.items, function(i,item){
            $("<img/>").attr("src", item.media.m).appendTo("#contenedor");
        });
    }
    </script>
</head>
<body>
    <input type="button" id="boton" value="probar" /><br />
    <div id="contenedor" />
</body>
</html>

Llamamos a la API, le decimos que el nombre de nuestra función es MiFuncion, cargamos dentro de un <script> generado dinámicamente y se ejecuta la llamada a MiFuncion, esta recibe los datos JSON y genera elementos <img> que se van agregando al DIV contenedor, mágico.

JSONP en jQuery

Los que acabamos de hacer funciona perfecto, pero es un poco trabajoso, para evitarnos semejante cantidad de trabajo jQuery ya trae la posibilidad de hacer llamadas JSONP y lo mejor es que lo hace de manera que es transparente para nosotros.

<html>
<head>
<script src="http://code.jquery.com/jquery-latest.min.js"></script>
<script type="text/javascript">
    $(function()
    {
        $("#boton").click(jsonp);
    });
    function jsonp()
    {
        var url = "http://api.flickr.com/services/feeds/photos_public.gne?tags=dog&format=json&jsoncallback=?";
        $.getJSON(url, null, function(data)
        {
            $.each(data.items, function(i,item){
                $("<img/>").attr("src", item.media.m).appendTo("#contenedor");
            });
        });
    }
    </script>
</head>
<body>
    <input type="button" id="boton" value="probar" /><br />
    <div id="contenedor" />
</body>
</html>

Vemos la generación dinámica del tag <script>

Básicamente la funcion getJSON al detectar la cadena callback=? en la URL que recibe genera automáticamente el tag <script> y llama a la URL reemplazando el ? por un nombre generado al azar, recupera la llamada y hace que el funcionamiento de JSONP sea transparente para nosotros, el parámetro jsoncallback es propio de la API de Flickr. Enjoy.

Referencias:

FlickAPI

jQuery getJSON

JSONP

Leonardo.

Twitter clon

2010-06-26T20:06:00.002-03:00

Un grupo de alumnos de la facultad han desarrollados dos proyectos con igual objetivo, un clon de Twitter, más precisamente un fontend que utiliza la API REST de Twitter, la idea era realizar una experiencia para ver cómo interactúan diferentes tecnologías que son parte de la materia arquitectura web:

HTTP
HTML
XML
Javascript
CSS
MVC
REST
AJAX

Finalmente la semana pasar quedó publicada la primer versión de los proyectos ambos dentro de una misma solución, dejo los links al primer release y al proyecto y mi más grande agradecimiento a los chicos por la participación y el esfuerzo.

Proyecto Twitter Clon

Primer Release Versión 0.1 beta

Saludos, Leonardo.

Recuperar la consulta generada por LinqToSql y ejecutar asincrónicamente

2010-06-03T18:05:00.001-03:00

Ejecución asincrónica y filtros dinámicos

Al interesante de LinqToSql (desde ahora L2S) es la que no genera la consulta hasta último momento si nos apoyamos en IQueryable, es decir, siempre que interactuemos con esta interface vamos a poder seguir agregando condiciones a nuestra consulta y el SQL resultante se va a resolver recién en el momento de ir a la base de datos, con esto quiero decir que no va a traer toda la tabla y después filtrar en memoria (por decirlo de una manera sencilla). Pero para resumir la cosa dejo un par de ejemplo de esto usando la base de datos AdventureWorks, enjoy.

/// <summary>
/// Ejemplo de generación de consulta LinqToSql y ejecución posterir con SqlCommand
/// </summary>
public static void LlamadaAsincronica()
{
//context Linq2Sql
DBDataContext _ctx = new DBDataContext();

    //Generamos la consulta
    var r = from p in _ctx.Products
            where p.ProductCategory.Name.StartsWith("b")
            select p;

    //en lugar de ejecutarla
    //recuperamos el command
    var c = _ctx.GetCommand(r) as System.Data.SqlClient.SqlCommand;

//tomamos el command text, o sea, el sql
var query = c.CommandText;

//convertimos los parámetros para pasarlos al query
var parametros = c.Parameters.Cast<System.Data.SqlClient.SqlParameter>().Select(p => p.Value).ToArray();

//lo ejecutamos asincrónicamente
var result = _ctx.ExecuteQuery<Product>(query, parametros);
}

/// <summary>
/// Ejemplo de suma de filtros
/// </summary>
public static void SumandoFiltros()
{
DBDataContext _ctx = new DBDataContext();

//generamos un IQueryable
var query = _ctx.Products.AsQueryable();

//colocamos un fitro
query = query.Where(p => p.ProductCategory.ParentProductCategoryID == 1).AsQueryable();

//agregamos uno más
query = query.Where(p => p.ProductID > 10);

//y magia se arma la consulta completa
var result = query.ToArray();
}

Mapeos locos

A modo de regalo dejo un lindo ejemplo que demuestra como L2S mapea un resultado a cualquier tipo que le digamos siempre que pueda resolverlo, simplemente creo la clase Dummy que tiene un par de propiedades que coinciden con Product.

    /// <summary>
    /// Ejemplo sobre cómo el framework de LinqToSql hace el mejor esfuerzo para
    /// mapear un resultado a un tipo de objeto que nosotros le digamos
    /// </summary>
    public static void MapearOtraCosa()
    {
        //context Linq2Sql
        DBDataContext _ctx = new DBDataContext();

        //Generamos la consulta
        var r = from p in _ctx.Products
                select p;

        //en lugar de ejecutarla
        //recuperamos el command
        var c = _ctx.GetCommand(r);

        //ejecutamos la consulta asincrónicamente y además le decimos que el resultado
        //lo mapee al tipo Dummy intentando hacer coincidir los nobmres de las
        //propiedades
        var result = _ctx.ExecuteQuery(typeof(Dummy), c.CommandText);
    }
}

public class Dummy
{
public int ProductID { get; set; }
public string Name { get; set; }
}

Mágico, nos vemos la próxima.

Des-Conferencia este sábado 22 de Mayo sobre NoSql con Java Lopez

2010-05-19T11:42:00.001-03:00

Este sábado 22 a las 18hs GMT habrá una reunión virttual de la gente de Alt.Net hispano sobre NoSql a cargo del maestro Angel Java Lopez, copio un poco de su post acá:

“El movimiento NoSQL apareció promoviendo el uso de almacenes de datos no relacionales. Surgió de varias fuentes y motivaciones, y tiene sus raíces aún en implementaciones anteriores a la aparición del modelo relacional.
Pasaremos revista, un poco a la historia, un poco a las primeras grandes implementaciones como BigTable de Google, o el Dynamo de Amazon. En los últimos años a aparecido una plétora de implementaciones, y se ha generado discusión sobre relacional vs NoSQL, cuándo, porqué.
Cómo cambia el diseño de una aplicación "normal" en NoSQL.
Queries, no más joins, denormalización.
No más esquemas.
Características deseables: cómo consiguen escalabilidad, alta disponibilidad, alto rendimiento.
El teorema CAP
Distintas formas de implementación:
Distribuidas vs No Distribuidas
En memoria vs En Disco
Key-Value vs Document vs Graph vs Column
Eventual Consistency
Proyectos más conocidos: Voldemort, Cassandra, CouchDB, MongoDB, SimpleDB, Memcached, BigTable, Dynamo, HBase...
Programaremos finalmente en .NET contra una de esas implementaciones, posiblemente MongoDB.
Espero que al final de la charla, todos tengamos una idea general de NoSQL, algunas características, código de ejemplo, disponible. Y entender, que al final, es una herramienta más: habrá casos en los que es más aplicable y otros en los que no.”

Nos vemos el sábado virtualmente ;) .

Error poco descriptivo en Microsoft Reporting

2010-05-10T12:07:00.001-03:00

En estos días me encuentro haciendo algunos reportes con Microsoft Reporting, una herramienta muy buena y poderosa, con la que incluso podemos invocar código .NET al generar reportes, etc. Por motivos de diseño de la aplicación que llama a la generación de reportes tengo que pasarle la gran mayoría de los datos como DataSources, hasta acá todo bien, en cierto momento haciendo esto:

localReport.DataSources.Add(new ReportDataSource("Dato", data));

me encontré con un mensaje de error muy poco descriptivo que me dejó desorientado, el mismo decía así:

"Value does not fall within the expected range."

ok, rápido fui al stacktrace esperando más detalles, pero el mismo no dice nada al respecto, luego fui a www.bing.com y tampoco encontré nada al respecto, de última eché mano del amigo Reflecto Pro y su increíble feature que permite ver el código de cualquier assembly (realmente con este tipo de cosas se paga sólo el Reflector) me encontré con que en el set del value del DataSource hay esto:

if ((value != null) && !((((value is DataTable) || (value is BindingSource)) || (value is System.Type)) || (value is IEnumerable)))
{
  throw new ArgumentException();
}

O sea que lanza una excepción porque no lo estaba pasando un dato de ninguno de estos tipo, con lo cual la solución fue hacer esto:

localReport.DataSources.Add(new ReportDataSource("Dato", new BindingSource() { DataSource = data }));

O sea, poner mi objeto dentro de un BindingSource, y santo remedio, secillo, pero oscuro. Nos leemos.

VAN sobre Moq publicada en Alt.Net hispano

2010-05-09T14:50:00.001-03:00

El pasado 27 de marzo tuve el honor de ser invitado por la gente de Alt.Net hispano a dar una VAN sobre Moq, fue una experiencia muy interesante sobre todo porque uno está sólo hablando a una pantalla y no sabe si los demás duermen o se fueron a pasear :) . Doy las gracias a Jorge Gamba y a todos los asistentes por la invitación, les dejo el link del video y los invito a participar de la comunidad.

VAN Sobre Moq en Alt.Net Hispano

PD: primer post desde Windows Live Writer

Reunión virtual sobre Moq este sábado por la tarde

2010-03-24T20:20:00.003-03:00

VAN sobre Moq este sábado 18hs GMT (15hs Bueno Aires)

Este sábado 27 de Marzo a las 18hs GMT (15hs de Argentina) la gente de Alt.Net Hispano organiza una VAN (Virtual Alt.Net) una reunión virtual para la cual es necesario acceder a la url http://snipr.com/virtualaltnet con NetMeeting (si no lo tenés te va a pedir que lo instales). El espíritu de esta reunión es compartir el conocimiento acerca de este tema de una manera lo más interactiva posible, para ello hay un google doc compartido para votar lo temas, sumar una al que más interese o proponer temas nuevos, es abierto. No va a hacer ppt, ya que vamos a ver todos los ejemplos a través del código, entonce, está hecha la invitación, espero ver sus nombre en el meeting este sábado.

Esto es lo que escribí en el post en la lista del Alt.Net

Resumen:

En la actualidad el software requiere altos niveles de calidad, las pruebas unitarias son una herramienta indispensable para alcanzar dicha calidad, desarrollar un software que sea fácil de probar requiere utilizar herramientas y patrones de diseño específicos, el mocking permite simular escenarios controlados para relizar nuestras pruebas. Dentro de los framework de mocking disponibles para .NET se destaca Moq por su facilidad de uso y limpieza de código, en este reunión virtual vamos a repasar los conceptos que son necesarios para una correcta prueba unitaria y descubriremos la potencia y belleza de Moq.

Curso de capacitación "ASP.NET MVC + jQuery en Acción"

2010-03-16T23:29:00.009-03:00

CURSO DE CAPACITACIÓN: "ASP.NET MVC + JQUERY EN ACCIÓN"

El lunes, 12 de abril de 2010 en el auditorio del MUG (Rivadavia 1479 1er Piso - Of. A - Ciudad de Buenos Aires) voy a estar dando un curso sobre ASP.NET MVC + jQuery, se va a dividir en tres encuentros, el primero el lunes 12 una clase teórica para treinta personas y luego dos días de práctica para quince personas cada uno, el martes 13 y el lunes 19, todo en el mismo lugar. La idea es cubrir los aspectos teóricos necesarios para comenzar a trabajar con estas tecnologías y después hacer una pequeña aplicación desde cero apovechando su capacidad de interacción. El temario es el siguiente:

jQuery:

NECESIDAD
SELECTORES
MANIPULACIÓN
EFECTOS
AJAX

ASP.NET MVC:

HTML
FORMULARIOS
POST GET
QUÉ ES MVC?
MODEL
VIEW
CONTROLLERS
ACTION FILTERS

Entonces nos vemos en el MUG, dejo el link para registrarse, hasta entonces.

UPDATE: Se agregó una fecha práctica más para el Martes 20 de Abril

Las fechas serían entonces:

Lunes 12/4 Teoría todos juntos en el auditorio
Martes 13/4 Práctica grupo 1 en el laboratoio
Lunes 19/4 Práctica grupo 2 en el laboratoio
Martes 20/4 Práctica grupo 3 en el laboratoio

No vemos allá, salut

UPDATE: pueden descargar la ppt desde acá y el ejemplo que desarrollamos durante la teoría acá

Charla en el MUG "Repasando VS 2008 - Introducción al Framework 3.5 y C#3.0"

2010-02-18T12:16:00.005-03:00

Repasando VS 2008 - Introducción al Framework 3.5 y C#3.0

La semana que viene voy a estar por el MUG dando una nueva charla, en este caso sobre cositas del framework 3.5 y C#3, la idea es ir haciendo el camino de los conceptos hasta llegar a Linq y sus variantes. Nos vemos en el MUG.

Fechas y Horarios: Miércoles 24 de febrero de 2010 de 18.30 a 21.30 hs.

Lugar: Auditorio del MUG: Rivadavia 1479 1er Piso - Ciudad de Buenos Aires.

Mientras esperamos la llegado del framework 4.0 y Visual Studio 2010 haremos un repaso de las características más sobresalientes de C#3 y Visual Studio 2008 que nos facilitan la tarea diaria y hacen la programación más entretenida.

Contenidos:

- Delegados

- Inicializadores

- Tipos anónimos

- qué es var?

- Métodos anónimos

- Propiedades automáticas

- Métodos de extensión

- Expresiones Lambda

- Linq - LinqToXml, LinqToSql -

Y otras características de C#3

EVENTO GRATUITO ignore la pregunta sobre forma de pago. VACANTES LIMITADAS.

UPDATE dejo un link con el código y la ppt de la charla

Actualizar Twitter desde .net

2010-02-06T22:58:00.005-03:00

Actualizar y recuperar el timeline de Twitter desde .net

Luego de una larga ausencia (que no se repetirá hasta que se repita) dejo un pequño ejemplo autodescriptivo sobre cómo actualizar y recuperar el timeline de Twitter con nuestro querido .net

Es un gran ejemplo sobre REST y las facilidades de System.Net y de LinqToXML, enjoy

using System;
using System.Linq;
using System.Net;
using System.Text;
using System.Xml.Linq;

namespace twitterUpdater
{
    /// <summary>
    /// Ejemplo sobre cómo actualizar twitter y leer el timeline desde .net
    /// http://apiwiki.twitter.com/Twitter-API-Documentation
    /// </summary>
    class Program
    {
        /// <summary>
        /// Nuestras credenciales de twitter
        /// </summary>
        public NetworkCredential Credential
        {
            get
            {
                return new NetworkCredential("leomicheloni", "mi_password");
            }
        }

        static void Main(string[] args)
        {
            var p = new Program();

            //Actualizamos nuestro estado
            p.Update("puedo tuitearte?");

            //traemos el timeline
            p.GetTimeLine();

            Console.ReadLine();
        }

        public void Update(string status)
        {
            var url = "http://twitter.com/statuses/update.xml?status={0}";

            var request = HttpWebRequest.Create(String.Format(url, status));

            request.ContentLength = 0; //el largo del contenido HTTP es cero porque todo lo necesario va en la url
            request.ContentType = "application/x-www-form-urlencoded"; ;
            request.Credentials = Credential; //nuestras credenciales de twitter
            request.Method = "POST"; //para enviar usamos el verbo POST

            //simplemente enviamos el request
            var response = request.GetResponse() as HttpWebResponse;

            if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Continue)
                throw new ApplicationException(response.StatusCode.ToString());
        }

        /// <summary>
        /// Recupera la actividad de las personas que seguimos y de nosotros mismos
        /// </summary>
        public void GetTimeLine()
        {
            var url = "http://twitter.com/statuses/friends_timeline.xml?count=3";

            var request = HttpWebRequest.Create(url);

            request.ContentLength = 0;
            request.ContentType = "application/x-www-form-urlencoded"; ;
            request.Credentials = Credential;
            request.Method = "GET"; //en este caso el verbo HTTP es GET

            var response = request.GetResponse() as HttpWebResponse;

            if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Continue)
                throw new ApplicationException(response.StatusCode.ToString());

            //recuperamos la respuesta
            var stream = response.GetResponseStream();

            var length = response.ContentLength;

            var buffer = new byte[length];

            stream.Read(buffer, 0, (int)length);

            var xml = Encoding.UTF8.GetString(buffer);

            //la respuesta es un xml como se especifica en http://apiwiki.twitter.com/Twitter-REST-API-Method%3A-statuses-friends_timeline
            var doc = XDocument.Parse(xml);

            var statuses = from item in doc.Document.Element("statuses").Nodes().ToArray()
                           select (item as XElement);

            foreach (var status in statuses)
            {
                Console.WriteLine(status.Element("user").Element("name").Value + " = " + status.Element("text").Value);
            }
        }
    }
}

Serialización binaria, ejemplo simple

2009-11-02T14:30:00.001-03:00

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Diagnostics;

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            //Crea el formatter que es el encargado de serializar
            var formatter = new BinaryFormatter();

            //Es necesario un Strema de cualquier tipo (un FileStream por ejemplo)
            var stream = new MemoryStream();

            //se instancia el objeto a serializar
            var o = new MyClass() { MyProperty = 1, MyProperty2 = "dos", PropiedadIgnorada ="Ignorar" };
            o.SetValorPrivado(true);

            //Se serializa el objeto y se pone en el Stream
            formatter.Serialize(stream, o);

            var data = stream.ToArray();

            //De-serializamos
            var o2 = (MyClass) formatter.Deserialize(new MemoryStream(data));

            
            //verificamos que el objeto de-serializado sea igual al original
            Debug.Assert(o.MyProperty.Equals(o2.MyProperty));
            Debug.Assert(o.MyProperty2.Equals(o2.MyProperty2));

            //La propiedad que no se serializó queda en null
            Debug.Assert(o2.PropiedadIgnorada==null);

            //notar que se serilizan los valores privados también
            Debug.Assert(o.VerificarValorPrivado().Equals(o2.VerificarValorPrivado()));
        }
    }

    //Las clases para serializar con el serializador binario tienen que estar marcadas
    //como Serilizable
    [Serializable]
    class MyClass
    {
        private bool _private;

        public int MyProperty { get; set; }
        public string MyProperty2 { get; set; }

        //con el atributo NonSerialized se ignoran propiedades
        //que no queremos serilizar
        [System.NonSerialized]
        public string PropiedadIgnorada;

        public void SetValorPrivado(bool valor)
        {
            _private = valor;
        }

        public bool VerificarValorPrivado()
        {
            return _private;
        }
    }
}

Teoría de objetos: Diferencia entre clase y objeto

2009-10-17T14:01:00.001-03:00

Diferencia entre clase y objeto

Antes que nada vamos a comenzar aclarando una diferencia que muchas veces cuesta comprender: diferencia entre clase y objeto

Clase: una clase es un molde, un concepto, una abstracción, por ejemplo: Automóvil
Objeto: un objeto es una instancia de una clase, un elemento concreto de una abstracción por ejemplo: MiAuto es una instacia de la clase auto

En C# sería así:

Clase Automóvil:

public class Automovil
{
    public void Arrancar();
    public string Marca { get; set; }
}

Objeto miAuto

Automovil miAuto = new Automovil();

Así comenzamos con una pequeña serie de pequeños post con conceptos básicos, espero que los disfruten. Hasta la próxima

Workshop con PC: "Desarrollando aplicaciones Web con herramientas y prácticas actuales".

2009-07-25T14:17:00.003-03:00

Los días Lunes 24, martes 25, Lunes 31 de Agosto y Martes 1 de septiembre de 18:30 a 21:30, estaré en las instalaciones del Grupo de usuarios de Microsoft dictando un workshop con máquina sobre desarrollo

La idea es ver el desarrollo de una aplicación web utilizando herramientas y técnicas de uso diario (un poco en contraposición al clásico "novedades de .net 12") para que podamos llevarnos conocimientos para aplicarlos en el día a día, si bien el temario es extenso nada quita que podamos ir abordando temas que surgan en el momento

En resumen, la idea es que todos aprendamos y nos llevemos algo que nos ayudea a mejorar nuestros desarrollos

Entre los temas centrales tenemos

ASP.NET MVC
UNIT TEST/ MOCKING
PATRONES
LINQ
EXPRESIONES LAMBDA
INVERSIÓN DE CONTROL/ INYECCIÓN DE DEPENDENCIAS
MÉTODOS DE EXTENSIÓN

Dejo el link de la charla para que se anoten, nos vemos en el MUG

UPDATE: Curso sobre desarrollo en el MUG

2009-07-16T17:37:00.005-03:00

Casi termino de redondear el temario para el pequeño curso que voy a dictar en el MUG seguramente a mitad de Agosto, aún falta definir si los cuatro encuentros ser dividirán en dos semanas de dos encuentros y cuatro de uno y los días, lo seguro es que será de 18:30 a 21:30. Dejo el temario actualizado.

Desarrollando aplicaciones Web con herramientas y prácticas actuales.

Cuatro sesiones recorriendo los elementos actuales del desarrollo web utilizando la tecnología.NET

1 - Conceptos básicos:
- Delegados, Eventos
- Reflector, la herramienta indispensable
- Extension methods
- Expresiones lambda
- Linq
- Refactor, mejorando el código
- Http, verbos, qué pasa en el cable?
- Html, css
- Fiddler, firebug, IEDeveloper toolbar herramientas para tener a mano
- Asp.net MVC. ¿Por qué? ¿Qué ventajas tiene?
- jQuery para acelerar el desarrollo de javascript
- Ajax para hacer más interactiva las aplicaciones
3-Mejorando el diseño:
- Más de lo anterior
- Desacoplando las cosas
- Patrones para todos los días Repository, Factory, etc.
- IoC
- Inyección de dependencias
- ORM
- Linq2sql
4-Testing y otras cuestiones:
- Aumentando la calidad de nuestra aplicación
- Unit test
- Code coverage. ¿Qué tanto se ha probado?
- Mocking
- TDD

Llamada a participación Ágiles2009 en Brasil

2009-07-01T11:25:00.001-03:00

Estimado colega,

Qué opinas de formar parte del equipo de expositores que reune nombres como Brian Marick, Diana Larsen, Matt Gelbwaks, Naresh Jain, Dave Nicolette, Alan Cyment, Alexandre Magno, entre otros?

El próximo lunes 6 de julio será la última oportunidad para presentar tu propuesta de charla en Ágiles 2009!

Ágiles 2009, a realizarse en Florianópolis, Brasil, es un evento sin fines de lucro, organizado por profesionales entusiastas del tema, unidos por el objetivo de crear un espacio amplio de discusión sobre las metodologías ágiles y su adopción en América Latina. Como expositor, tendrás acceso libre a la conferencia y otras ventajas que los organizadores están preparando para ti! Puedes proponer una presentación, un tutorial, un reporte de experiencias o un workshop.

Accede a http://www.agiles2009.org/es/submissions.php para ver la información que debes proporcionar para presentar tus propuestas.

Esperamos contar contigo en Ágiles 2009!

Comité Organizador www.agiles2009.org

Qué temas y con qué profundidad te gustaría ver en una capacitación?

2009-06-30T19:28:00.010-03:00

Estoy delineando algunas ideas para una capacitación con máquina y todo en 2, 3 o 4 encuentros. La idea es ver algunos de los temas que fui presentando en el MUG pero aplicados a problemas reales y vinculados, como "en la vida real"

Qué temas tratar?

La idea es ver:

Delegados y esas cosas
Linq
Exmpresiones Lambda
Linq2Sql o Entity Framework
ASP.NET MVC
jQuery
IoC
Un poco de patrones
Mocking
TDD
Algunas herramientas como Fiddler, Visual Studio, nUnit, etc.

La idea es recopilar adeptos para armar el curso e ir definiendo el temario para definir el tiempo y sobre todo el costo (si, van a tener que pagar para escucharme :P )

Condiciones

El lugar será el MUG y el horario de 18:30 a 21:30 ya que me parece que pocos pueden (incluído yo) pedirse 3 o 4 días para algo así

Bueno, tiro la piedra, espero sumar adeptos e idea y las iremos sumando para que sea una buena experiencia y que todos podamos aprender

UPDATE

Más o menos voy dando forma al temario, a ver qué les parece

Desarrollo de una aplicacion Web con herramientas y prácticas actuales, en .NET, obvio.

-Conceptos básicos, para entender lo otro:

Delegados
Eventos
Reflector, la herramienta indispensable
Extension methods
Expresiones lambda
Linq
Refactor, mejorando el código
Http, verbos, qué pasa en el cable?
Html, css

-Comenzando con la aplicación web, de a poco:

Fiddler, firebug, IEDeveloper toolbar herramientas para tener a mano
Asp.net MVC, por qué, qué ventajas tiene?
jQuery para acelerar el desarrollo de javascript
Ajax para hacer más interactiva las aplicaciones

-Mejorando el diseño:

Más de lo anterior
Desacoplando las cosas
Patrones para todos los días Repository, Factory, etc.
IoC
Inyección de dependencias
ORM
Linq2sql

-Testing:

Aumentando la calidad de nuestra aplicación
Unit test
Code coverage, qué tanto se ha probado?
Mocking
TDD

Es una idea pero para ir definiendo cosas, sobretodo el objetivo, cómo vincular los conceptos de uso diario y actuales

Cómo pasar elementos desde una lista a otra con javascript: con la ayuda de jQuery

2009-06-24T23:09:00.003-03:00

Intercambio de items entre listas con jQuery

Como digo siempre el verdadero poder de jQuery se encuentra en los selectores, si bien uno se entusiasma inicialmente con los efectos, animaciones, etc. con el tiempo uno se da cuenta que en el día a día jQuery y sus selectores son sus verdadres aliados, para demostrar esto vamos a ver un ejemplo sencillo de una tarea no tan simple

Seguramente les ha tocado tener que hacer la típica pantalla con dos listas, en la cual se pasan elementos de una a la otra. Se habrán encontrado con algunos problemas para localizar los elementos, verificar que cuando querramos pasar de una lista a la otra haya algo seleccionado, etc. He visto ejemplos de código bien pulidos con unas cuantas líneas de javascript y no tan claro pero que funcionan, bueno, vamos a ver cómo se puede hacer esto con jQuery con 3 o 4 líneas gracias a los selectores

<script language="javascript" type="text/javascript">
$(function()
{
    $("#add").click(function()
    {
        mover("origen", "destino");
    }); 
    
    $("#remove").click(function()
    {
        mover("destino","origen");
    });           
});

function mover(origen, destino)
{
    $("#" + origen + " option:selected").remove().appendTo("#" + destino);
}
</script>

Y el HTML sería

<table>
    <tr>
        <td>
            <select id="origen" multiple="multiple" size="5">
                <option value="1">uno</option>
                <option value="2">dos</option>
                <option value="3">tres</option>
                <option value="4">cuatro</option>
            </select>
        </td>
        <td>
            <input type="button" id="add" value=">" /><br />
            <input type="button" id="remove" value="<" />
        </td>
        <td>
            <select id="destino" size="5">
                <option value="5">cinco</option>
            </select>
        </td>
    </tr>
</table>

Mágico, no sólo es sencillo, sino que podemos usar la función mover para mover elementos desde cualquier lista a otra con varios elementos seleccionados, incluso si fuera un combo y todo gracias a los selectores. Hasta la próxima

Vinculando AJAX + ASP.NET MVC + jQuery

2009-06-10T17:34:00.002-03:00

La forma fácil de bindear datos entre jQuery y ASP.NET MVC. DataBinders

Una de las ventajas de ASP.NET MVC es la capacidad de los DataBinders, que no son más que piezas de código que permiten relacionar la información que llega a una acción de un controlador con los parámetros del controlador, esto es, si desde una página llega un campo por POST con cierto nombre, etc cómo se convierte en un parámetro de la acción del controlador, a través de un DataBinder. Si bien podemos crear nuestros propios DataBinders de manera sencilla, con lo que viene por defecto con ASP.NET MVC resuelve la mayoría de los problemas, tanto es así que esta pequeña pieza de códiigo va a intentar vincular los datos con los parámetros de una acción haciendo su mejor esfuerzo desligandonos de tal problema.

Usando Objetos en los parámetros de las acciones

La gracia de usar objetos como parámetros de las acciones es mucha, es decir, si la acción recibe los datos de un formulario de alta de un usuario por qué no crear un tipo de datos RegisterForm usarlo como parámetro y ver cómo hacemos para que nuestras páginas puedan "bindear" sus datos al parámetro. No, en principio no hay que escribir un DataBinder, porque podemos aprovechar la intereporabilidad entre jQuery y ASP.NET MVC y no hacer absolutamente nada raro para que esto ocurra.

Cómo hacer el binding automático si usamos AJAX con jQuery?

Esta es la parte divertida del asunto, imaginemos que tenemos un formulario con un panel para que usuario ingrese al sistema, pero es una aplicación bien "ajaxificada" y el formulario envía los datos asincrónicamente y la respuesta llega del mismo modo, todo sin cambiar de página,

    <div style="width: 180px">
    <form id="formulario">
    <fieldset>
    <input type="text" id="NOMBRE" name="NOMBRE" />
    <input type="text" id="APELLIDO" name="APELLIDO"/>
    <input type="text" name="EDAD" id="EDAD" />
    <input type="text" id="EMAIL" name="EMAIL" /><br /> 
    <input type="checkbox" id="TERMINOS" name="TERMINOS" /><span>Aceptar términos</span>  <br /> 
    <input type="button" id="enviar" value="Enviar" />
    </fieldset>
    </form>
    </div>

Bien, este el es formulario, como vemos hay varios campos, entonces definamos una clase simplemente para mapear las propiedades de éste

public class RegisterForm
{
    public string Nombre { get; set; }
    public string Apellido { get; set; }
    public int Edad { get; set; }
    public string Email { get; set; }
    public string Terminos { get; set; }

}

Perfecto, ahora hacemos una acción en nuestro controller para que tome los datos del formulario

public ActionResult BindingTest(RegisterForm registerForm)
{
    return Json(registerForm);
}

Esta acción siemplemente toma los datos y los devuelve en JSON como para verlos en el cliente nomás, a modo de prueba, la idea es por supuesto hacer algo con ellos, entonces, cómo hacemos para invocar con AJAX la acción y de paso que todos los datos del formulario se "bindeen" o vinculen con el parámetro, así:

<script language="javascript" type="text/javascript">
    $(function() {
        $("#enviar").click(sendData);
    });
    
    function sendData() {
        $.get("/home/BindingTest/", $("#formulario").serialize(), function(data) {
            alert(data);
        });        
    }
</script>

Estoy usando jQuery, y como verán es un simple get con AJAX, el truco está en la función serialize(), que seriliza el formulario, o sea, transforma el objeto y su estado de modo que se pueda transportar o guardar, en este caso como un querystring que es perfectamente comprensible por ASP.NET MVC y sobre todo por el ModelBinder por defecto, como resultado vemos lo que funciona de pelos, porque imprimimos la respuesta de la acción en un alert y comprobamos que el objeto se cargó y luego fue devuelto por la accion en formato JSON, mágico

Hasta la próxima.

Ágiles 2009 en Brasil

2009-06-09T08:28:00.005-03:00

Como continuidad de los que fue el éxito de Ágiles 2008 les cuento que la versión 2009 se va a realizar en el hermano país de Brasil, más específicamente en Florianópolis, pueden seguir el progreso de la organización desde Acá y si tienen ganas colaborar :) , la fecha es octubre y ya confirmó Brian Marick uno de los firmantes del manifiesto ágil allá por el 2001, así que la invitación está hecha, les aseguro que voy a tratar de estar, no olviden que siempre se pueden consultar las novedades de la comunidad en el sitio de ágiles y las actividades no son pocas por suerte. Saludos.

Charla MVC desde cero en el MUG DONE!!

2009-05-27T19:51:00.004-03:00

Ayer junto a mi secuaz de laburos freelance Rodrigo Obi-Wan Iloro tuvimos el agrado de dar una pequeña charla introductoria acerca de ASP.NET MVC en el Microsoft User Group, una vez más tengo que agradecerles a todos los que concurrieron y a la gente del MUG por su buena onda

Dejo la PPT que usamos ayer, voy a ir subiendo los ejemplos e intentar de explicar un poco junto con cada uno (remarco la palabra intentar, siempre prometo y no tengo tiempo después), así que enjoy. PPT ASP.NET MVC desde cero

UPDATE!!! Código de ejemplo

Alt.Net Argetina 09 Fotos

2009-05-23T20:03:00.004-03:00

Con un poco de retraso pero aquí dejo el link a algunas fotos de Alt.Net Argentina versión 2009, la verdad es que fue muy bueno, intentaré dejar mis impresiones sobre las charlas en las que participé durante estas semanas

Álbun de todos Flickr

¿Cómo hacemos una interface fluyente o fluent interface?

2009-05-20T10:31:00.001-03:00

Cómo crear una fluent interface? o métodos que fluyen

Este pequeño post viene a colación sobre una pregunta acerca de un estilo interesante de diseño de fremwork las Fluent interface, están por todos lados jQuery, Moq, Rhino Mocks, por nombrar herramientas que nombré en este blog

Qué es una Fluent Interface, o interface fluyente?

Sencillo, es cuando podemos hacer llamadas a un metodo e ir encadenando llamadas sucesivas, por ejemplo en jQuery

$("div").draggable().resizable()

Es decir, llamamos a un método y el mismo nos permite hacer llamadas sucesivas a otros métodos. Interesante, pero cómo se hace? bien vamos directamente al código autodescriptivo

class Program
{
    static void Main(string[] args)
    {
        var fluent = new Fluent();

        //Lamamos a la clase "fluyente" repetidamente para ir agregando mensajes
        //por defector Console.WriteLine llama al método ToString que sobre-escrimos
        Console.WriteLine(
            fluent.AddMessage("hola ").AddMessage(" mundo").AddMessage("que tal?"));

        Console.ReadLine();
    }
}

/// <summary>
/// Esta clase tiene algunos método "fluet" o sea, "flueyente", todo el truco
/// está en que dicos métodos devuelvan una referencia el mismo objeto
/// o sea this
/// </summary>
public class Fluent
{
    StringBuilder _messageList = new StringBuilder();

    /// <summary>
    /// Los métdos "fluyentes" devuelven un objeto del mismo tipo
    /// que la clase que los contiene, en definitiva, devuelven
    /// el mismo objeto con this
    /// </summary>
    /// <returns>El mismo objeto que contiene el método</returns>
    public Fluent AddMessage(string message)
    {
        _messageList.AppendLine(message);
        return this;        
    }

    /// <summary>
    /// Sobre-escribimos el ToString para ver el resultado
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return _messageList.ToString();
    }
}

Lo ejecutamos y mágia! Hasta la próxima

Charla sobre jQuery en el MUG DONE - ppt

2009-05-12T22:52:00.007-03:00

Recién llego de la presentación sobre jQuery en el MUG, la verdad es que estuvo muy bueno, al menos yo la pase bien :) . Gracias a todos los asistentes y a la gente del MUG, dejo la presentación que usé esta noche, en estoy días voy a subir los ejemplos de código como prometí, de paso voy a agregar algunas cosas que surgieron, como databindings para los objetos dom y tabs con AJAX.

Bajar archivo presentación (Skydrive)

UPDATE!!!

Código de los ejemplos

Charla sobre ASP.NET MVC en el MUG

2009-04-24T11:47:00.003-03:00

Charla ASP.NET MVC en el MUG

Vamos a estar dando una charla introductoria a ASP.NET MVC en el Microsoft User Group el día 26 de Mayo después del trabajdo, digo vamos porque me va a dar una mano Rodrigo Alias "Obi" un experto en la materia, la idea es ver un poco de teoría y aprovechar el marco del MUG para darle mucho al código y que la cosa sea lo más interactiva y enriquecedora posible para todos, no me queda otra que empezar a preparar el material así que trataré de ir subiendo cosas, no se olviden que el 9 del mayo (quince días antes) vamos a ver un poco de JQuery en otra charla del MUG, si el entusiasmo lo permite tenemos en mente armar algo más tipo capacitación con las dos cosas, así que están todos invitados, dejo el link

ASP.NET MVC desde cero

Charla sobre JQuery en el MUG

2009-04-03T15:10:00.004-03:00

Charla sobre JQuery en el Microsoft User Grouop

Una vez más tengo que agradecer a la gente del MUG la posiblidad de estar en las instalaciones de la calle Rivadavia con una charla, en este caso sobre JQuery el framework de Javascript del que todos hablan (no sé si es así pero queda bien). La idea es ir viendo de a poco cómo se utiliza y qué tipo de cosas podemos resolver facilmente con su ayuda a través de ejemplos de código, como me gusta a mí :P . Así que los invito a participar, vamos a ver cómo hacer selecciones, manipulaciones de elementos, animaciones, Ajax, invocación de Web Services, todo desde Javascript muy fácil gracias a JQuery, les dejo el link para que se anoten y apurensé que todos mis familiares se van a anotar para hacer bulto.

JQuery la respuesta para el desarrollo de aplicaciones web ricas con Javascript y Ajax

Alt.Net En Argentina y LA

2009-03-20T11:28:00.004-03:00

Hace unas horas ha nacido la versión regional de Alt.Net y se ha creado un grupo (muy a mi pesar en googlegroups) para la organización y demás menesteres, así que a participar.

Predicado con parámetros o cómo poder pasar un parámetro al método Find de List

2009-03-18T14:51:00.001-03:00

Predicados con parámetros

Una vez más un post que surge de una consulta cotidiana, un predicado es un tipo de delegado, o sea una firma de un método, en el caso del predicado genérico (que es el que nos interesa) la firma es la siguiente

public delegate bool Predicate<T>(T obj);

Entonces, lo que esto nos dice es que representamos un método que recibe T como parámetro y devuelve true o false, el objetivo de un predicado es que ese valor de retorno responda a una condición que nosotros consideramos verdadera, por ejemplo T fuese un tipo persona podriamos decir que será true el valor de retorno cuando su edad sea mayor de dieciocho años, para ser claro, un método que responda a esa regla y represente un predicado sería así:

private Predicate<Persona> PredicadoConParametro(string param)
{
    return new Predicate<Persona>(delegate(Persona target)
    {
        return target.Edad > 18;
    });
}

La duda es, si quiero que ese valor (18) sea parametrizable tengo que poner el predicado in-line para que "vea" el valor, así:

public void PredicadoInLine()
{
    List<Persona> personas = new List<Persona>()
    {
        new Persona{Nombre = "Enzo", Edad=36}, new Persona{Nombre = "Ariel", Edad=30}
    };

    int edad = 18;

    personas.Find(delegate(Persona target)
    {
        return target.Edad > edad;
    });
}

Es claro que el problema es que si queremos tener el código del predicado en otro lado por los motivos que sea y necesitamos pasar un parámetro (en este caso la edad) no hay forma (con una variable global se puede..) entonces la solución sería poder tener un predicado con parámetros, bien, cómo se resuelve esto? vamos a analizar un poco

Lo que nos pide el mètodo Find es un predicado, nada nos impide poner un método que retorne un predicado, y a ese método pasarme un parámetro, en nuestro caso la solución sería así:

/// <summary>
/// Este método acepta un parámetro edad y devuelve un predicado, es lo que necesitamos 
/// para pasar al método Find de la lista
/// </summary>
private Predicate<Persona> PredicadoConParametro(int edad)
{
    return new Predicate<Persona>(delegate(Persona target)
    {
        return target.Edad > edad;
    });
}

public void Probar()
{
    //declaramos la lista con dos elementos
    List<Persona> personas = new List<Persona>()
    {
        new Persona{Nombre = "Enzo", Edad=36}, new Persona{Nombre = "Carlos", Edad=10}
    };

    //Verificamos que llamando al método Find de la lista utilizando nuestro predicado parametrizado nos
    //devuelva un elemento al menos
    Debug.Assert(personas.Find(PredicadoConParametro(18)) != null);
}

El método PerdicadoConParametro acepta un parámetro edad y devuelve un predicado que tiene en cuena esa edad, con lo cual cubrimos nuestro requerimiento. Mágico, hasta la próxima

La comunidad ágil hispanoparlante y su crecimiento

2009-03-18T11:08:00.007-03:00

Como parte de toda este increible crecimiento que se está dando en la comunidad ágil de Argentina y acompañado con el resto de latam impulsado por las Primeras Jornadas ágiles de Latinoamérica, las reuiones mensuales, el muy exitoso Open Space de este més, y por supuesto el sitio de la comunidad ahora se suma el nuevo nombre de la lista de correo de LAASD que a partir de ahora como forma de centrar todos los mensajes de todos los paises de habla hispana cuya dirección es foro-agiles@yahoogroups.com, así que anotensé y hagamos cada vez más grande nuestra comunidad, la versión para Argentina es link. Saludos.

Agile Open en Baires 09

2009-01-28T12:01:00.001-02:00

Open Space en Buenos Aires, Universidad de 3 de Febrero.

El próximo 6 y 7 de Marzo en la Sede Centro Cultural Borges de la Universidad de 3 de Febero se realizará un Open Space para 100 personas con entrada libre y gratuita organizado por la comunidad agiles.org. Creo que va a ser una experiencia muy buena para todos y muy interesante, el tema a tratar "Implementando desarrollo ágil", nos vemos allá.

Charla sobre mocking en el MUG, Done!!

2008-11-18T22:43:00.007-02:00

Hoy tuve la suerte de poder dar una charla sobre mocking en el Grupo de Usuarios de Microsoft de Argentina, hablamos de los objetivos del mocking, de Rhino Mocks y Moq sin olvidar hacer referencia de NMock y TypeMock.

Agradezco a los asistentes, al MUG, y a Daniel Laco por todo.

Dejo los ejemplos para descargar

¿Cómo verificar el orden de las llamadas a métodos con Moq?

2008-11-03T20:27:00.000-02:00

¿Cómo verificar el orden de las llamadas a métodos con Moq 2.6?

En algunas ocasiones necesitamos verificar en qué orden son llamados métodos que hemos "mockeado" una vez más vemos que nuestro querido Moq no tiene una posibilidad para hacerlo como si la tiene Rhino, pero por supuesto, todo se puede solucionar de la mano de los Callbacks, de esta manera:

public interface IFoo
{
    void Method1();
    void Method2();
    void Method3();
}

public class Sequencer
{
    Posicion contador;

    public enum Posicion
    {
        Primero = 1,
        Segundo = 2,
        Tercero = 3,
        Cuarto = 4
    }

    public void Seq(Posicion place)
    {
        if (++contador != place)
            throw new InvalidOperationException(
                string.Format("El método ha sido llamado {0} pero debería ser llamado {1}", contador,place));
    }        
}

[TestMethod]
public void VerificarOrdenDeLlamadas()
{
    var mock = new Mock<IFoo>();
    var seq = new Sequencer();

    mock.Expect(p => p.Method1()).Callback(() => seq.Seq(Sequencer.Posicion.Primero));
    mock.Expect(p => p.Method2()).Callback(() => seq.Seq(Sequencer.Posicion.Segundo));
    mock.Expect(p => p.Method3()).Callback(() => seq.Seq(Sequencer.Posicion.Tercero));

    mock.Object.Method2();

    mock.Object.Method1();

    mock.Object.Method3();

}

Simple, hasta la próxima.

Ágiles 2008, una utopía hecha realidad

2008-10-24T17:11:00.002-02:00

Bueno, han finalizado las primeras jornadas latinoamericanas sobre metodologías ágiles, de las cuales tuve el hornor de participar en la organización. Fueron diez meses desde el puntapié inicial en la lista de laass, luego de muchos desalientos, tropezones y otras yerbas, finalizaron ayer con el salón Bolivar del hotel Bauen a pleno para ver un panel de cierre de lujo formado por Mary y Tom Poppendieck, Tobiar Mayer, Matt Gelbwaks, Dave Nicolette y Micah Martin, esto lo tenemos filmado y vamos a ver cómo hacemos para subirlo.

Unas últimas palabras de Martín Salías para emocionarnos a todos que son un poco el resumen de los que pasó, no puedo agregar nada a lo que dijo Martín, un gran agradecimiento a todas las personas que fueron y a todos los organizadores, creo que todos nos llevamos una experiencia única y momento que van a quedar grabados para siempre, como la foto final de todo el equipo que demuestra que las personas son lo más importante, tuve la oportunidad de interactuar la mayoría y no tengo más que elogíos para todos por su entrega y su calidez personal, gracias chicas y chicos y veremos qué pasa el año próximo.

Foto del salón bolivar durante el panel de cierre (cortesía del blog de Martín)

[VIDEO] Intro rápida a Data Access Application Block de Enterprise Library 3.1

2008-10-16T18:15:00.005-03:00

Les dejo un video muy breve sobre Data Access Application Block, saludos

Introducción a DAAB
El mismo video en rapidshare

Moq 2.6: Mocks recursivos

2008-10-14T11:04:00.003-03:00

Automocking con Moq

Una de las novedades de la versión 2.6 de nuestro framework de mocking preferido Moq es al automocking que no es otra cosa más que un mockign jerárquico, es decir si "mockeamos" un objeto (interface o lo que sea) y este tiene dentro otros objetos también se hace mocking de estos y podemos configurar un resultado o comportamiento de cualquiera de ellos, lo cual es muy práctico, veamos cómo funciona.

public interface IPersona
{
    string Nombre { get; set; }
    //La propiedad Direccion es otro objeto
    IDireccion Direccion { get; set; }
}

public interface IDireccion
{
    string Calle { get; set; }
    int Altura { get; set; }
}

[TestMethod]
public void AutoMocking()
{
    var mock = new Mock<IPersona>();

    //automáticamente se crea un mock object para la propiedad Dirección de modo lazy
    mock.Expect(persona => persona.Direccion.Calle).Returns("Cucha Cucha");

    Assert.AreEqual<string>("Cucha Cucha", mock.Object.Direccion.Calle);
}

No nos asustemos pensado que esto va a hacer que el automocking tome 40 segundos en crear un objeto hasta que resuelve todos los objetos que tiene dentro, la creación de los automocking es del tipo lazy, es decir, se crea sobre demanda, mágico. Saludos.

Charla en el Microsoft User Group de Argentina, sobre Mocking

2008-10-10T16:20:00.000-03:00

Charla en el Microsoft User Group de Argentina

Finalmente llegó el día, el próximo 18 de Noviembre voy a estar dando una charla en el MUG, el título será:

Mock Objects como solución para pruebas en ambientes complejos.

La misma estará orientada a desarrolladores y equipos que utlizan pruebas de unidad y son concientes de la problemática de probar componentes con depencias de otros componentes que van más allá del ámbito de la prueba, como interfaces, repositorios de datos, conexiones de red, etc.

La idea es hablar un poco del modelo de mocking basado en inyección de dependencias, es decir, como Rhino Mocks y Moq, y a lo sumo nombrar TypeMock Isolator, hacer unos ejemplos de dependecias de componentes y ver cómo se pueden diseñar las aplicaciones para disminuir el acoplamiento y poder utlizar mocking para crear pruebas unitarias de calidad, vamos a ver un poco de Rhino y mucho de nuestro framework preferido Moq, todo a través de ejemplos.

Tengo que agradecer por esta oportunidad a la gente del MUG por supuesto y especialmente a Daniel Laco.

El link de la charla es este

http://www.mug.org.ar/Eventos/3125.aspx

Nos vemos en el MUG.

¿Cómo verificar la cantidad de llamadas a un miembro con Moq?

2008-10-06T10:48:00.001-03:00

¿Cómo verificar la cantidad de llamadas a un miembro con Moq?

Si hay utlizado Moq como yo también Rhino Mocks seguramente se han encontrado con la ausencia de un modo de verificar la cantidad de llamadas que se hacen sobre un miembre, digamos propiedad o método, o sea, configuramos nuestras Expectations y de alguna manera queresmos asegurarnos que tal miembro es llamado un número exácto de veces, es se hace en Rhino más o menos así

[TestMethod]
public void VerificarCantidadDeLlamadasConRhino()
{
    Rhino.Mocks.MockRepository mocker = new Rhino.Mocks.MockRepository();

    var mock = mocker.CreateMock<IFoo>();

    using (mocker.Record())
    {
        Rhino.Mocks.Expect.Call(mock.DoInt(2)).Return(22).Repeat.Times(3);
    }

    //Rhino hace la verificación al salir del bloque using
    using (mocker.Playback())
    {
        Assert.AreEqual<int>(22, mock.DoInt(2));
        Assert.AreEqual<int>(22, mock.DoInt(2));
        Assert.AreEqual<int>(22, mock.DoInt(2));
    }
}

Ahora bien, nuestro querido Moq no dispones de esa característica,¿ por qué?, porque la idea de Kzu es que Moq sea muy sencillo (no entremos en discusiones del tipo por qué se mezclan Stubs y Mocks porque no tienen sentido) esto es muy bueno y la verdad es que me encanta, pero nos deja con ese problema, cómo lo resolvemos?

Callbacks, la solución

Los Callbacks son acciones que podemos indicar al Moq que realize un Mock cuando se invoca a uno de sus miembros, o sea, configuramos un Expectation a un miembro y de paso le podemos decir a Moq que cuando este miembro sea invocado que haga algo más que puede no tener ninguna relación con el Mock, entonces lo que tenemos que hacer para verificar que un método es llamado un número exácto de veces (o mayor o menor, lo que sea) es configurar un Callback en el miembro que incremente un contador y luego con un Assert verificar el contador, y listo el pollo, de esta manera:

[TestMethod]
public void VerificarCantidadDeLlamadasConMoq()
{
    var mock = new Mock<IFoo>();
    int contador = 0;

    //al configurar el Expectation agregamos un Callback que incrementa contador
    mock.Expect(x => x.DoInt(2)).Returns(22).Callback(()=>contador++);

    Assert.AreEqual<int>(22, mock.Object.DoInt(2));
    Assert.AreEqual<int>(22, mock.Object.DoInt(2));
    Assert.AreEqual<int>(22, mock.Object.DoInt(2));

    //verificamos contador y listo
    Assert.AreEqual<int>(3,contador);
}

Conclusión

Personalmente me sigue pareciendo mucho más clara la sintáxis de Moq, en definitiva puede ser que Moq sea demasiado sencillo y mezcle conceptos de TDD para serlo, pero la realidad es que es mejor ser productivo que ortodoxo, no? hasta la próxima.

Sindicar contenido con WCF y sobrecarga de métodos

2008-09-28T19:57:00.001-03:00

Syndication con WCF, sobrecarga de métodos de paso.

Otra de las funcionalidades que se agregaron con el assemblie System.ServiceModel.Web es la posibilidad de sindicar contenido al estilo .net o sea, fácil y tipificado de verdad, es tán fácil que vamos a ir diréctamente al ejemplo de código. Vamos a ver que en este caso definí una interface del servicio con los atributos, esto es lo más natural y nos da un extra de flexiblidad y un poco más de limpieza en el código que hacerlo como en los ejemplos anteriores:

[ServiceContract]
[ServiceKnownType(typeof(Atom10FeedFormatter))] //indica la forma de serializar los datos Atom
[ServiceKnownType(typeof(Rss20FeedFormatter))]
public interface IServicioPrueba
{
    [OperationContract]
    [WebGet] //se usa webget porque tanto RSS con Atom corren sobre HTTP y se invocan con verbos HTTP
    SyndicationFeedFormatter Feed(string tipo);

    [OperationContract]
    [WebGet]
    SyndicationFeedFormatter Feed();
}

public class ServicioPrueba : IServicioPrueba
{
    /// <summary>
    /// Este método nos permite elegir si queremos Atom, sino RSS
    /// </summary>
    public SyndicationFeedFormatter Feed(string tipo)
    {
        SyndicationFeed feed = GenerarFeed();

        if (tipo.Equals("atom"))
        {
            return new Atom10FeedFormatter(feed);
        }
        else
        {
            return new Rss20FeedFormatter(feed);
        }
    }

    /// <summary>
    /// Genera un feed con dos entradas
    /// </summary>
    private static SyndicationFeed GenerarFeed()
    {
        IList<SyndicationItem> items = new List<SyndicationItem>();

        items.Add(new SyndicationItem("primer noticia", "extra extra cupido apesta!", null));
        items.Add(new SyndicationItem("segunda noticia", "Meteoro no seas tonto el enmascarado es tu hermano", null));

        SyndicationFeed feed = new SyndicationFeed(items);
        return feed;
    }

    /// <summary>
    /// En este método lo publicamos como Rss las clases Rss20FeedFormatter y Atom10FeedFormatter heredas
    /// de SyndicationFeedFormatter por lo tanto se pueden intercambiar casi indistintamente (tiene su especialización)
    /// </summary>
    /// <returns></returns>
    public SyndicationFeedFormatter Feed()
    {
        return new Rss20FeedFormatter(GenerarFeed());
    }
}

Por último el host

static void Main(string[] args)
{
    string address = "http://localhost:8080/servicio/";

    using(ServiceHost host = new ServiceHost(typeof(ServicioPrueba)))
    {                            
        //Creamos un endpoint igual al de REST
        ServiceEndpoint endPoint = new ServiceEndpoint(ContractDescription.GetContract(typeof(IServicioPrueba)), 
            new WebHttpBinding(), new EndpointAddress(address));

        endPoint.Behaviors.Add(new WebHttpBehavior());

        host.Description.Endpoints.Add(endPoint);

        Console.WriteLine("inicializando..");
        host.Open();
        Console.WriteLine("iniciado..");
        Console.ReadLine();
        Console.WriteLine("cerrando...");
        host.Close();
        Console.WriteLine("listo");
    }
}

Lo que hice fue crear dos métodos, uno (Feed) que devuelve siempre el canal en Rss y otro con un parámetro que nos permite elegir el formato. Si intentamos correr esto vamos a recibir un error muy feo del tipo InvalidOperationException y es porque estamos intentando sobrecargar métodos en WCF.

Sobrecarga de método en WCF

Sí, se pueden sobrecargar métodos en WCF, de echo lo hacemos y al compilar todo va bien, hasta que hacemos Open() del host y todo explota. ¿Qué ocurre? simple, al hacer Open() WCF comieza a generar la metadata para el servicio, como siempre utilizar WSDL y WSDL es SOAP (o naturalmente lo es), y a pesar que SOAP es "Simple Object Access Protocol" (ya sé que desde la versión 1.2 no lo es), no soporta conceptos de orientación a objetos como la sobrecarga por lo tanto BOOM, no funciona.

La metadata generada para el servicio a pesar que el WebHttpBinding es WSDL

<?xml version="1.0" encoding="utf8" ?>
 <wsdl:definitions name="ServicioPrueba" targetNamespace="http://tempuri.org/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:wsu="http://docs.oasisopen.org/wss/2004/01/oasis200401wsswssecurityutility1.0.xsd" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:wsam="http://www.w3.org/2007/05/addressing/metadata" xmlns:tns="http://tempuri.org/" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/08/addressing" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsap="http://schemas.xmlsoap.org/ws/2004/08/addressing/policy" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msc="http://schemas.microsoft.com/ws/2005/12/wsdl/contract" xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:wsa10="http://www.w3.org/2005/08/addressing" xmlns:wsx="http://schemas.xmlsoap.org/ws/2004/09/mex">
   <wsdl:types>
     <xsd:schema targetNamespace="http://tempuri.org/Imports">
      <xsd:import schemaLocation="http://localhost:8080/servicio/?xsd=xsd3" namespace="http://tempuri.org/" />
      <xsd:import schemaLocation="http://localhost:8080/servicio/?xsd=xsd0" namespace="http://schemas.microsoft.com/2003/10/Serialization/" />
      <xsd:import schemaLocation="http://localhost:8080/servicio/?xsd=xsd1" namespace="http://schemas.datacontract.org/2004/07/System.ServiceModel.Syndication" />
      <xsd:import schemaLocation="http://localhost:8080/servicio/?xsd=xsd2" namespace="http://www.w3.org/2005/Atom" />
    </xsd:schema>
  </wsdl:types>
   <wsdl:message name="IServicioPrueba_Feed_InputMessage">
    <wsdl:part name="parameters" element="tns:Feed" />
  </wsdl:message>
   <wsdl:message name="IServicioPrueba_Feed_OutputMessage">
    <wsdl:part name="parameters" element="tns:FeedResponse" />
  </wsdl:message>
   <wsdl:portType name="IServicioPrueba">
     <wsdl:operation name="Feed">
      <wsdl:input wsaw:Action="http://tempuri.org/IServicioPrueba/Feed" message="tns:IServicioPrueba_Feed_InputMessage" />
      <wsdl:output wsaw:Action="http://tempuri.org/IServicioPrueba/FeedResponse" message="tns:IServicioPrueba_Feed_OutputMessage" />
    </wsdl:operation>
  </wsdl:portType>
   <wsdl:binding name="WebHttpBinding_IServicioPrueba" type="tns:IServicioPrueba">
     <wsdl:operation name="Feed">
      <wsdl:input />
      <wsdl:output />
    </wsdl:operation>
  </wsdl:binding>
   <wsdl:service name="ServicioPrueba">
    <wsdl:port name="WebHttpBinding_IServicioPrueba" binding="tns:WebHttpBinding_IServicioPrueba" />
  </wsdl:service>
</wsdl:definitions>

¿Entonces cuál es la solución?

La solución es utilizar un alias para los métodos, ya sé que van a decir que entonces es como si tuvieran otro nombre, y tienen razón, pero parcialmente, si consumimos un servicio WCF desde WCF podemos llamar al mismo método en una u otra sobrecarga (utilizando la interface cliente no el proxy svcutility.exe en caso de usar el proxy se puede editar a mano)

Entonces el código de la interface queda así:

[ServiceContract]
[ServiceKnownType(typeof(Atom10FeedFormatter))] //indica la forma de serializar los datos Atom
[ServiceKnownType(typeof(Rss20FeedFormatter))]
public interface IServicioPrueba
{
    [OperationContract(Name = "default")]//alias para esta operación
    [WebGet] //se usa webget porque tanto RSS con Atom corren sobre HTTP y se invocan con verbos HTTP
    SyndicationFeedFormatter Feed(string tipo);

    [OperationContract]
    [WebGet]
    SyndicationFeedFormatter Feed();
}

Y listo, ahora funciona

Mágico una vez más, hasta la próxima.

Referencias

SOAP W3C

WSDL W3C

WCF Syndication MDSN

REST en WCF

2008-09-21T18:46:00.003-03:00

REST con WCF

Siguiendo con el tema de WCF vamos a ver que fácil que es exponer un nuevo endPoint para un servicio existente para publicarlo de otra manera, en el post anterior vimos cómo crear un servicio y exponerlo "a la antigua" para que sea compatible con ASMX, ahora vamos a ver que simple que es tomar el mismo código y exponer el servicio como una api REST ya que está de moda.

REST una arquitectura

La idea de rest es aprovechar las capacidades del protocolo HTTP para utilizarlo como arquitectura de servicios, es decir: ¿si ya tenemos un protocolo que todos comprenden por qué no aprovecharlo para exponer servicios en lugar de ponerle otros protocolos arribla, como SOAP? gran idea, además ahorramos overhead. Tenemos los verbos necesarios para hacer las operaciones (GET, POST, DELETE y PUT), las direcciones, el formato, todo universal, por lo tanto podemos aprovecharlo.

Framework 3.5

Para poder utilizar REST sobre WCF es necesario instalar el Framework 3.5, el assemblie que contiene la funcionalidad es System.ServiceModel.Web, así que hay que referenciarlo, una vez que hacemos esto el código es éste:

namespace PruebaWCF
{
    class Program
    {
        static void Main(string[] args)
        {
            string uriRest = "http://localhost:8080/rest/";

            using (ServiceHost host = new ServiceHost(typeof(MiServicio)))
            {
                ContractDescription description = ContractDescription.GetContract(typeof(MiServicio));

                //cambiamos el binding por WebHttpBinding
                ServiceEndpoint endPointREST = new ServiceEndpoint(description,
                    new WebHttpBinding(), new EndpointAddress(uriRest));

                //agregamos un comportamiento al endPoint del tipo WebHttpBehavior
                endPointREST.Behaviors.Add(new WebHttpBehavior());

                //agregamos el endPoint al servicio
                host.Description.Endpoints.Add(endPointREST);

                //por último abrimos el host
                host.Open();

                Console.WriteLine("iniciado..");
                Console.ReadLine();
                //cuando se presiona enter ser cierra el servicio
                host.Close();
                Console.WriteLine("finalizado..");
            }
        }
    }

    /// <summary>
    /// Con ServiceContract indicamos que éste es un contrato de servicio
    /// </summary>
    [ServiceContract]
    public class MiServicio
    {
        /// <summary>
        /// Con OperationContract indicamos que esta operación es un operación del servicio
        /// </summary>
        [OperationContract]
        //sólo es necesario este atributo para permitir la invocación del tipo Http Get
        [WebGet]
        public string Saludo(string nombre)
        {
            return string.Concat("Hola ", nombre);
        }
    }

}

Super mágico, hasta la próxima.

Referencias

REST

HTTP

Framework 3.5

Introducción a WCF ABC, con cliente ASMX

2008-09-17T10:28:00.003-03:00

WCF

Windows Comunication Foundation es un SDK para desarrollar servicio de Microsoft, es parte del framework 3, necesita framework 2 y el framework 3.5 agrega algunas extensiones como el soporte para servicios REST.

La idea principal detrás de WCF es un modelo unificado de desarrollo de servicios independiente de detalles de implementación como el protocolo de transporte, la seguridad, etc

Entonces podemos tener un único servicio programado de una manera particular y exponerlo de diferentes formas, cada punto de contacto con el exterior de un servicio en WCF se conoce como Endpoint. Por lo tanto decimos que un servicio WCF tiene un numero de Endpoints, cada cual diferenciado por dirección, puerto, protocolo de transporte, etc.

El ABC

Cada vez que veamos una introducción a WCF vamos a ver que se habla del ABC, esto es,

A: Address, la dirección del servicio. Está relacionado obviamente con el protocolo, ya que si es http seguramente el address comenzará con http.

B: Binding, el protocolo de transporte o mejor dicho el esquema de transporte porque es algo más que el protoloco, entre ellos HTTP, TCP, Named pipes, MSMQ, etc.

C: Contract, el contrato, es decir las acciones y tipos que expone el servicio.

Hosting

Seguramente se están preguntando cómo "hostear" los servicio, bien, hay un par de alternativas, IIS, en una aplicación .net cualquiera (un servicio de windows, una aplicación de consola) o con WAS (Windows activation service), en estos ejemplos vamos a utilizar una aplicación de consola .net.

Vamos a los bifes.

Como no me gusta dar vueltas, me parece que lo mejor es ver cómo hacemos para crear un servicio y tener varios Endpoint (por ahora uno y lo vamos a ir modificando en otros posts). Antes que nada necesitamos Visual Studio 2005 + la extensiones para framework 3 o directamente cualquier versión de Visual Studio 2008.

Agregamos el assemblie System.ServiceModel.dll y listo, veámos el código auto-descriptivo.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace PruebaWCF
{
    /// <summary>
    /// Con ServiceContract indicamos que éste es un contrato de servicio
    /// </summary>
    [ServiceContract]
    public class MiServicio
    {
        /// <summary>
        /// Con OperationContract indicamos que esta operación es un operación del servicio
        /// </summary>
        [OperationContract]
        public string Saludo(string nombre)
        {
            return string.Concat("Hola ", nombre);
        }
    }
}}

Como vemos es una simple clase con un par de atributos para indicar algunas cosas al WCF ( más adelante vamos a ver que es más interesante extraer la interface con los atributos pero por ahora lo dejamos así para que se más fácil).

Con esto tenemos el servicio terminado, sólo falta "hostearlo", vamos a ver cómo se hace y cómo configuramos los bindings, behaviors, endpoints y etc./p>

Hosteando nuestro primer servicio WCF

Para el primer ejemplo vamos a utilizar un Binding que nos permite utlizar este servicio con un cliente .net 2.0 clásico, el binding que nos permite esto es el BasicHttpBinding.

La configuración

La configuración es un tema medio pesado, ya que hay muchas cosas que configurar (cuanto más flexible mas complejo), si bien se han agregado algunos "factories" para facilitar la creación de servicios cuando se "hostean" en IIS, nosotros por el momento vamos a ver alguinos ejemplos sencillos. La configuración puede hacerce por código o por archivo de configuración, la segunda opción permite más flexibilidad ya que podemos cambiar muchas cosas sin recompilar como agregar un registro de sucesos, autenticación, endonints, etc. si bien no todo se puede hacer por configuración es un poco pesado el tema, por lo tanto vamos a ver los ejemplos haciéndolo por código que de paso quedan más claros los conceptos.

Behaviors

Lo último que voy a contar antes del código es sobre los behaviors o comportamientos, hay de dos niveles, de nivel servicio (afectan a todos los endpoints) y a nivel endpoint, qué permiten hacer? por ejemplo registrar los mensajes, publicar la metadata, algo personalizado, etc.

Ahora sí, el código de nuestro host

namespace PruebaWCF
{
    class Program
    {
        static void Main(string[] args)
        {
            string uri = "http://localhost:8080/servicio/";

            using(ServiceHost host = new ServiceHost(typeof(MiServicio)))
            {
                //definimos un endpoint para el servicio del tipo
                //basicHttpBinding que es compatible con servicios asmx
                //como vemos en la forma más sencilla sólo necesitamos 2 líneas
                //de código para configurar un servicio WCF
                ServiceEndpoint endPoint = new ServiceEndpoint(
                        ContractDescription.GetContract(typeof(MiServicio)),
                        new BasicHttpBinding(), new EndpointAddress(uri));

                host.Description.Endpoints.Add(endPoint);

                //este comportamiento indica que se va a publicar la metadata del servicio
                //para poder generar el proxy desde el lado del cliente más facilmente
                //una vez que tenemos el proxy generado no es necesario esto
                ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                behavior.HttpGetEnabled = true;
                behavior.HttpGetUrl = new Uri(uri);

                host.Description.Behaviors.Add(behavior);

                //por último abrimos el host
                host.Open();

                Console.WriteLine("iniciado..");
                Console.ReadLine();
                //cuando se presiona enter ser cierra el servicio
                host.Close();
                Console.WriteLine("finalizado..");
            }
        }
    }
}

La clase ServiceHost se encarga de "hostear" nuestro servicio, entonces creamos un Endpoint con:

Contrato: ContractDescription.GetContract(typeof(MiServicio))

Binding: BasicHttpBinding para que sea compatible con un cliente asmx

Address: new EndpointAddress(url)

Los agregadomos al host con host.Description.Endpoints.Add(endPoint)

y listo, ya funciona haciendo host.Open().

Le agregué el ServiceMetadataBehavior para que se publique la metadata del servicio apra poder generar el proxy desde Visual Studio 2005 con un cliente asmx, después se puede quitar este behavior y diría que es casi recomendable, un detalle es que puedo publicar la metadata en otra url, yo lo hice en la misma por comodidad.

Consumiendo un servicio WCF desde ASMX

Y llegamos a la parte interesante, si tuvieramos un servicio publicado cuyos clientes con asmx y se nos ocurre actulizarlo a WCF por motivos valederos (como por ejemplo porque es más lindo) nada está perdido, el servicio que acabamos de generar es compatible con asmx y lo vamos a demostrar.

Agregamos la referencia como simpre

Un poco de código del lado del cliente para invocar al servicio WCF

class Program
{
    static void Main(string[] args)
    {
        WCFService.MiServicio servicio = new WCFService.MiServicio();
        Console.WriteLine(servicio.Saludo("leonardo"));

        Console.ReadLine();
    }
}

Y listo, mágico.Hasta la próxima

Referencias:

Visión global de la arquitectura de WCF MSDN

ABC de la programación de WCF

Ágiles 2008 - primera versión del programa

2008-09-11T00:15:00.002-03:00

Está disponible en http://agiles2008.org/es/programa.php la primera versión del programa de lo que serán la primeras jornadas de desarrollo ágil de Latinoamérica, para los que se anotaron ya pueden ir viendo cuales de las charlas simultáneas van a ver (no creo que haya muchos cambios con la versión final), lo que no se anotaron están a tiempo de hacerlo Aquí asique nos vemos el 22 y 23 de Octubre en el Bauen.

Saludos.

Hashtables, diccionarios e igualdad en las colecciones.

2008-09-08T01:02:00.000-03:00

Hashtables, diccionarios e igualdad en las colecciones

Existen algunas colecciones que se utilizan para trabajar con elementos que vamos considerar diferentes a partir de alguna característica que los identifica, que los hace únicos, se llaman diccionarios, y justamente la interface IDictionary es la que nos permite implementar este tipo de funcionalidad, veamos un poco cómo es:

public interface IDictionary : ICollection, IEnumerable
{
    // Methods
    void Add(object key, object value);
    void Clear();
    bool Contains(object key);
    IDictionaryEnumerator GetEnumerator();
    void Remove(object key);

    // Properties
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[object key] { get; set; }
    ICollection Keys { get; }
    ICollection Values { get; }
}

El método Add nos permite agregar un elemento indicando dos cosas, "key" la clave que nosotros consideramos el atributo que identifica a nuestro elemento frente a otros y "value" el objeto en sí, como vemos en esta implementación ambos parámetros son del tipo object, dentro de Generics tenemos una implementación de IDictionary tipificada.

Entonces podemos llamar al método Contains y preguntar por una "key" en particular y la colección nos debería contestar si existe dentro de la colección.

Implementación del método GetEnumerator

El método GetEnumerator como vimos antes se encuentra dentro de la interface IEnumerable, pero no en este caso, porque la interface IDictionary define su propio método GetEnumerator, por lo tanto oculta la definición de IEnumerable, ok, ¿por qué IDictionary tiene su propia versión de GetEnumerator? porque IEnumerable.GetEnumerator devuelve una interface IEnumerator que es así

public interface IEnumerator
{
    bool MoveNext();
    object Current { get; }
    void Reset();
}

El problema es que en IDictionary trabajamos con objetos + un elemento que los identifica (la "key") y el método Current de IEnumerator devuelve un object, por lo tanto no nos alcanza para saber la "key" y el "value" por separado (como lo ingresamos a través del método Add), entonces veamos qué nos devuelve la implementación de GetEnumerator de IDictionary

public interface IDictionaryEnumerator : IEnumerator
{
    DictionaryEntry Entry { get; }
    object Key { get; }
    object Value { get; }
}

Vemos que hereda de IEnumerator y además agrega algunas propiedades para trabajar con "key" y "value" y con un tipo DictionaryEntry

public struct DictionaryEntry
{
    private object _key;
    private object _value;
    public DictionaryEntry(object key, object value);
    public object Key { get; set; }
    public object Value { get; set; }
}

Lo mismo, "value" y "key" por separado, ahora todo cierra, bien, explicado esto nos damos cuenta que podemos iterar sobre un IDictionary y además recuperar información de clave-valor del elemento actual así.

foreach (DictionaryEntry item in hashTable)
{
    Console.WriteLine(item.Key);
    Console.WriteLine(item.Value);
}

Igualdad en los diccionarios

Como dije antes los diccionarios nos aseguran tener sólo elementos diferentes dentro de ella basandose para determinar qué es diferente en la "key", bien, pero esto tiene algunos detalles a tener un cuenta siempre que se trabaje con diccionarios.

Imaginemos que tenemos esta clase

public class Persona
{
    private string _nombre;
    private int _dni;

    public int Dni
    {
        get { return _dni; }
        set { _dni = value; }
    }

    public string Nombre
    {
      get { return _nombre; }
      set { _nombre = value; }
    }
}

Sencilla, bien, y creamos una Hashtable y hacemos esto

Hashtable hashTable = new Hashtable();

Persona persona1 = new Persona() { Nombre = "Leonardo", Dni=123};
Persona persona2 = new Persona() { Nombre = "Leonardo", Dni=123};

hashTable[persona1] = persona1;
hashTable[persona2] = persona2;

Console.WriteLine(hashTable.Count);

Muy bien, creamos dos objetos iguales (al menos desde nuestro punto de vista) y le decimos en dos ocaciones a la Hashtable su valor (el mismo) sin embargo cuando corremos la aplicación vemos que tenemos dos elementos dentro de la Hashtable, ¿por qué?

¿GetHashCode y Equals cómo funcionan en los diccionarios?

Bueno, lo que pasa es que primeramente Hashtable se fija en el resultado del método GetHashCode de cada objeto para saber si es igual a otro, bien, nosotros no dijimos cómo debe comportarse este método, pero como todos los objetos (o sea todo) en .NET hereda de object éste tiene su implementación de GetHashCode que devuelve un Hash diferente para cada instancia de object, como resultado podemos crer n instancias de Personas iguales y todas van a retornar un hash diferente.

Entonces para implementar correctamente GetHashCode tenemos que pensar bien, en función de nuestro dominio cuándo dos objetos de la misma clase se consideran diferentes, en el caso de Persona el nombre no hace diferentes a dos personas (puede haber muchos habitantes con el mismo nombre) sin embargo el Dni (en Argentina es el nro de documento único) sí hace únicas a las personas, entonces es un buen candidato para determinar cuándo dos objetos de la clase Persona son diferentes o no.

public class Persona
{
    private string _nombre;
    private int _dni;

    public int Dni
    {
        get { return _dni; }
        set { _dni = value; }
    }

    public string Nombre
    {
        get { return _nombre; }
        set { _nombre = value; }
    }

    public override int GetHashCode()
    {
        return _dni.GetHashCode();
    }
    public override bool Equals(object obj)
    {
        return ((Persona)obj).Dni.Equals(_dni);
    }
}

Perfecto, ahora sí funciona, ya que para nosotros el Dni es la propiedad que determina si dos Persona son iguales utilizamos el hash del mismo (la clase int devuelve el mismo hash para dos números con el mismo valor), prestemos atención que también he sobre-escrito el método Equals porque la Hashtable lo consulta en caso de que el resultado de GetHashCode sea igual, por lo tanto, sino lo sobre-escribimos tampoco va a considerar ambos elementos iguales.

La interfece IEqualityComparer

Hay otra forma de indicar a la Hashtable cómo determinar si dos elementos son iguales, esto es especialmente útil si nos encontramos con una condición de igualdad particular (ya que si suministramos IEqualityComparer la Hashtable no va a llamar a los métodos GetHashCode y Equals de los objetos) o si no queremos o podemos implementar GetHashCode y Equals en la clase, veamos su firma.

public interface IEqualityComparer
{
    bool Equals(object x, object y);
    int GetHashCode(object obj);
}

La idea es como vemos hacer lo mismo (definir GetHashCode y Equals) pero en otra clase y pasársela a la Hashtable, entonces para el ejemplo anterior la cosa sería así

public class ComparadorPersonas : IEqualityComparer
{
    public int GetHashCode(object obj)
    {
        return ((Persona)obj).Dni.GetHashCode();
    }

    public new bool Equals(object x, object y)
    {
        return ((Persona)x).Dni.Equals(((Persona)y).Dni);
    }
}

Y se utiliza así

private void Test()
{
    Hashtable hashTable = new Hashtable(new ComparadorPersonas());

    Persona persona1 = new Persona() { Nombre = "Leonardo", Dni = 123 };
    Persona persona2 = new Persona() { Nombre = "Leonardo", Dni = 123 };

    hashTable[persona1] = persona1;
    hashTable[persona2] = persona2;

    Console.WriteLine(hashTable.Count);
}

Y listo, funciona.

Conclusión

Los diccionarios nos permite manipular una lista de elementos únicos, utiliza una propiedad "key" para identificar los elementos. Es muy importante implementar correctamente los métodos GetHashCode y Equals para que la Hashtable pueda controlar la repetición de los elementos. Podemos utilizar la interface IEqualityComparer para realizar comparaciones personalizadas o por fuera de la clase. Hasta la próxima.

Referencias

Interface IDictionary (MSDN)

Hashtabls (MSDN)

Jornadas Ágiles 2008 - Inscríbase ahora!

2008-09-06T17:05:00.001-03:00

Está abierta la inscripción a las Jornadas Ágiles 2008, a realizarse los días 22 y 23 de Octubre de 2008 en el Hotel Bauen, Buenos Aires, Argentina. Ágiles 2008 es una excelente oportunidad para encontrarse con profesionales de IT de la región, interesados en compartir sus experiencias, debatir y capacitarse en temas relacionados con el desarrollo de software a través del uso de metodologías ágiles.

Entre los invitados internacionales que participarán en Ágiles 2008 se encuentran Matt Gelbwaks, Tobias Mayer, Dave Nicolette y los keynote speakers del evento, Mary y Tom Poppendieck.

El programa incluirá distintos tipos de actividades: presentaciones, sesiones interactivas, talleres y espacios abiertos de debate. Las jornadas son gratuitas pero es necesario registrarse para reservar un lugar.

El formulario de inscripción está en http://www.agiles2008.org/es/registracion.php

Más información relacionada con el evento, el hotel y el programa en www.agiles2008.org

Cualquier inquietud, envíenos un mail a info@agiles2008.org

Comité Organizador Ágiles 2008 www.agiles2008.org

[Platinum Sponsors] Intel, Sabre Holding

[Gold Sponsors] Three Melons, VersionOne, Microsoft

[Silver Sponsor] Baufest, Hexacta, Liveware

[Institucionales] Scrum Alliance, IEEE, SADIO, Agile Alliance, Polo Tecnológico Rosario, Córdoba Technology, Cessi Argentina

IList la interface de escritura

2008-08-28T21:52:00.000-03:00

IList la interface de escritura

En el post anterior hablé acerca de IEnumerable, una linda interface que está en toda colección que se precie de serlo posee, pero que no nos deja más que leer, si lo que necesitamos es poder escribir la interface es IList, vamos a ver su firma

public interface IList : ICollection, IEnumerable
{
    int Add(object value);
    void Clear();
    bool Contains(object value);
    int IndexOf(object value);
    void Insert(int index, object value);
    void Remove(object value);
    void RemoveAt(int index);

    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
    object this[int index] { get; set; }
}

Como vemos IList implementa IEnumerable o sea que la podemos iterar con foreach, y también implementa ICollection, veámos de qué se trata:

public interface ICollection : IEnumerable
{
    void CopyTo(Array array, int index);

    int Count { get; }
    bool IsSynchronized { get; }
    object SyncRoot { get; }
}

ICollection para qué sirve?

Esta interface tiene métodos para iterar y sincronizar, los métodos para iterar los hereda de IEnumerable y ya los conocemos, vamos a detenernos en los otros

CopyTo: sirve para copiar el contenido de la clase que implementa ICollection al Array que se pasa como parámetro a partir de la posición del Array que se indica en index

IsSynchonized: indica si la colección se encuentra implementado "Threat safe"

SyncRoot: devuelve un objeto para sincronizar la colección en un ambiente multi hilo, para hacer un lock

Ahora sí, IList

IList tiene los métodos necesarios para poder agregar elementos, verificar que existan, la posición de un elemento determinado, etc.

Dónde encontramos IList?

La implementación más sencilla de IList se encuentra en la clase ArrayList, por lo tanto podemos concluir que ArrayList es la colección más sencilla que podemos utilizar y que seguramente vamos a utilizar con mayor frecuencia (esto es un poco mentira por generics pero eso lo vamos a ver más adelante)

ArrayList también implementa mucho métodos que no pertenecen a ninguna interface, algunos muy interesantes son

Sort: para ordenar la lista, con un IComparer por defecto y una sobrecarga para suministrarle uno propio.

BinarySearch: para búsqueda binaria, es decir, busca de a mitades.

ConvertAll: permite convertir todos los elemento de un tipo a otro, el converter se lo suministramos nosotros

El resto de los métodos son bastante autodescriptivos, hasta la próxima.

Error 1935.An error occurred during the installation of assembly - HRESULT: 0x80070020

2008-08-28T19:51:00.000-03:00

Error 1935.An error occurred during the installation of assembly

Estaba yo intentando instalar el Visual Studio 2008 porque lo había quitado de mí máquina por motivos que no vienen al caso y me encontré con el siguiente error "Error 1935.An error occurred during the installation of assembly...." y el nombre de un aseembly y a continuación "HRESULT: 0x80070020", esto no hubiera sido tan grave sino fuera porque me apareción casi al final de la instalación que no es de las más cortas que he visto, y además a continuación le llevó más tiempo hacer el rollback, pero bueno, el mayor problema es que no tenía idea de qué pasaba, luego de "bucear" por Intenet llegué a la conclusión que se trataba de un error al intentar registrar una DLL (porque por supuesto intenté otra vez y pasó lo mismo con otro nombre de DLL) entre muchos consejos se encontraban desactivar los AdAware, los Antivirus, etc. eso no hubiera sido raro sino fuera porque no tengo nada de eso en la máquina, en fin, seguí buscando y encontré la solución....desactivar todos los servicios que no sean de Microsoft, entonces fui a ejecutar "msconfig" desactivé Procesar Archivo SYSTEM.INI y CARGAR ELEMENTO DE INICIO, luego fui a la solapa de servicio y seleccioné "Ocultar todos los servicios de Microsoft", desactivé todo lo que quedó, reinicié la máquina y santo remedio, pude instalar, pero no sin quedarme con la duda de qué pasaba.

Lo importante es el HRESULT

Lo importante para encontrar la solución fue el HRESULT del error, por supuesto que no lo anoté, para encontrarlo fui al directoril temporal de mi usuario "ejecutar->%temp%" y busqué un archivo txt con un nombre del estilo err_vs_algo y ahí estaba la información, porque el error 1935 es muy genérico en realidad, lo que importa, como dije antes es el HRESULT.

Saludos.

Colecciones en .NET, IEnumerator, IEnumerable.

2008-08-28T16:51:00.003-03:00

Las colecciones son uno de los recursos más utilizados (sino el más) dentro del mundo de .net, es importante comprender bien su funcionamiento y su potencial, ya que una decisión correcta nos puede facilitar mucho el trabajo y hasta tener impácto en el rendimiento de nuestra aplicación.

En .net 2.0 existen tres tipos de colecciones:

Colecciones normales
Colecciones especializadas
Coleccioner genéricas

Vamos a comenzar por el principio, por las colecciones normales, y para ser más básico aún vamos a ver la interface que todos usan.

Con ustedes IEnumerator

Esta interface está hasta en la sopa, todas las colecciones de .net la utilizan y es importante comprender cómo funciona, el bucle foreach (uno de los más grandes inventos de la época) también y la interface IEnumerable la base de Linq, entonces vamos a analizarla

public interface IEnumerator
{
    object Current { get; }
    bool MoveNext();
    void Reset();
}

La idea es que la clase que implemente IEnumerator posee una conjunto de elemento de un tipo (una lista, un array, un vector) y los métodos de IEnumerator me permite acceder a esta lista de una manera estándar.

Current: esta propiedad devuelve el elemento actual donde se encuentra apuntada la lista, es decir, sila lista tiene 10 elemento por convensión el método Current nos devuelve el primer elemento.
MoveNext: Con este método le decimos a la clase que lo implementa que mueva su posición al siguiente elemento en su lista, es decir, si actualmente está en el elemento 5 luego de ejecutar MoveNext deberá pasar al 6 y devolverá true, siempre y cuando el 6 exista, en caso de no existir el elemento 6 no se moverá y devolverá false, en lugar de true. Con este método podemos poner un bucle while por ejemplo y movernos por toda la lista.
Reset: pone al principio la posición actual de la lista.

Se va la segunda IEnumerable

IEnumerator no sirve de mucho sin su fiel aliado, IEnumerable, esta interface es muy sencilla y no hace más que devolver en su único método la interface IEnumerator, veamos su firma

public interface IEnumerable 
{ 
    IEnumerator GetEnumerator(); 
}

Exáctamente esto es lo que tenemos que implementar si queremos que una clase nuestra se pueda iterar con un bucle foreach, vamos a ver un pequeño ejemplo.

[TestFixture]
public class Class1
{
    [Test]
    public void ProbarLista()
    {
        ContenedorLista lista = new ContenedorLista(new object[]{1,2,3,4,5,6,7,8,9,0});

        foreach (int nro in lista)
        {
            NUnit.Core.TestContext.Out.WriteLine(nro);
        }

        Console.ReadLine();
    }
}
public class ContenedorLista: IEnumerable
{
    IEnumerator _istaPropia;

    public ContenedorLista(object[] lista)
    {
        _istaPropia = new ListaPropia(lista);
    }

    public IEnumerator GetEnumerator()
    {
        return _istaPropia;
    }
}

public class ListaPropia : IEnumerator
{
    object[] _lista;
    int _posicion;

    public ListaPropia(object[] lista)
    {
        _lista = lista;
        this.Reset();
    }

    public object Current 
    {
        get 
        {
            return _lista[_posicion];
        }
    }

    public bool MoveNext()
    {
        if (++_posicion < _lista.Length)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public void Reset()
    {
        _posicion = -1;
    }
}

Mágico sin duda, bueno por ahora esta primer entrega sobre colecciones termina, la próxima vamos a ver otras interfaces, saludos.

¿Cuándo utilizar MockObjects?

2008-08-25T12:55:00.000-03:00

¿Cuándo utilizar MockObjects?

Los mock objects con mágicos, nos permiten evitar un montón de problemas en nuestras pruebas y mejorar mucho su calidad, pero no hay que usarlos siempre, leyendo un libro me encontré con algunos tips sobre cuándo utlizarlos:

El objeto real tiene un comportamiento no-determinístico (produce resultados impredecibles).
El objeto real es difícil de configurar, como el sistema de archivos, la base de datos o una red
El objeto real tiene un comportamiento que es difícil de disparar (por ejemplo un error de red).
El objeto real el lento.
El objeto real tiene (o es) una interfaz de usuario.
La prueba necesita saber cómo son utilizados los objetos (por ejemplo se necesita saber si una función callback ha sido llamada).
El objeto real no existe aún (un problema común cuando se interactúa con otros equipos o con nuevos sistema de hardware).

Referncia: Tim Mackinnon, Steve Freeman, and Philip Craig. Endo-testing: Unit testing with mock objects.

Hasta la próxima.

Soy desarrollador Gold

2008-08-22T21:20:00.003-03:00

Desarrollador Gold

Sí, después de tener un poco abandonado el tema del DCE me puse las pilas como se dice en Argentina y rendí los exámenes que me faltaban para ser desarrollador gold, ahora a ver qué pasa con la estrella platinium.

Nuevo Blog sobre Sharepoint Services desde cero

2008-08-15T20:49:00.005-03:00

Recién salido del horno, un nuevo blog sobre sharepoint en donde la autora irá compartiendo sus experiencias (el camino hacia la certificación) con los lectores, el tema, obviamente Sharepoint services 3, en el primer post Paula nos muestra cómo instalar WSS3 desde cero y crear nuestro primer site collection. Disfrútenlo.

Blog: Punto de encuentro

Utilizando expresiones Lambda para facilitar la creación de métodos anónimos

2008-08-11T12:59:00.001-03:00

Utilizando las expresiones lambda para facilitar algunos trabajos molestos

Más de una vez nos encontramos con la necesidad de ordenar una lista tipada (o sea una lista generica) y es necesario implementar IComparer<T>, no es que sea para mucho, es sólo un método como vemos en su definición

using System;

namespace System.Collections.Generic
{
    public interface IComparer<T>
    {
        int Compare(T x, T y);
    }
}

pero más de una vez no tenemos ganas de crear una clase para esto o implementarla en una existente, bueno, para evitar hacer esto podemos utilizar un delegado y valernos de la inferencia de tipos de C# del siguiente modo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication10
{
    class Program
    {
        static void Main(string[] args)
        {
            new Program().Prueba();
            Console.ReadLine();
        }

        private void Prueba()
        {
            List<Persona> personas = new List<Persona>()
            {
                new Persona() { Nombre = "Hernán", Apellido = "Crespo" },
                new Persona() { Nombre = "Leonardo", Apellido = "Micheloni" },
                new Persona() { Nombre = "Enzo", Apellido = "Francescoli" },
                new Persona() { Nombre = "Ariel", Apellido = "Ortega" }
            };

            personas.Sort(delegate(Persona x, Persona y)
            {
                return x.Apellido.CompareTo(y.Apellido);
            });

            personas.ForEach(Console.WriteLine);         
        }
    }

    public class Persona
    {
        private string _nombre;

        public string Nombre
        {
            get { return _nombre; }
            set { _nombre = value; }
        }
        private string _apellido;

        public string Apellido
        {
            get { return _apellido; }
            set { _apellido = value; }
        }

        public override string ToString()
        {
            return string.Format("{0} {1}", this.Apellido, this.Nombre);
        }
    }
}

Y esto funciona muy bien, simplemente creamos un delegado que represente al método Compare<Persona> y la inferencia de tipos hacer el resto, lee el método anónimo se fija los parámetros, el valor de retorno, en cuál de las sobrecargas del método Sort encaja y listo, mágico y muy bonito, pero vamos a ir un paso más allá.

Facilitando la creación de métodos anónimos con expresiones Lambda

Por definición las expresiones Lambda son funciones anónimas que pueden contener expresiones o declaraciones y pueden ser utilizadas para crear delegados o árboles de expresión, entonces podemos reemplazar el delegado con una bonita expresión Lambda, sí, de este modo:

private void Prueba()
{
    List<Persona> personas = new List<Persona>()
    {
        new Persona() { Nombre = "Hernán", Apellido = "Crespo" },
        new Persona() { Nombre = "Leonardo", Apellido = "Micheloni" },
        new Persona() { Nombre = "Enzo", Apellido = "Francescoli" },
        new Persona() { Nombre = "Ariel", Apellido = "Ortega" }
    };

    personas.Sort((x, y) => x.Apellido.CompareTo(y.Apellido));

    personas.ForEach(Console.WriteLine);         
}

Hermoso, con una linda línea podemos ordenar el listado de ídolos de River Plate (en el cual me incluyu :-P ) y si descompilamos con Reflector vemos lo que pasó

internal class Program
{
    // Methods
    private static void Main(string[] args)
    {
        new Program().Prueba();
        Console.ReadLine();
    }

    private void Prueba()
    {
        List<Persona> <>g__initLocal0 = new List<Persona>();
        Persona <>g__initLocal1 = new Persona();
        <>g__initLocal1.Nombre = "Hern\x00e1n";
        <>g__initLocal1.Apellido = "Crespo";
        <>g__initLocal0.Add(<>g__initLocal1);
        Persona <>g__initLocal2 = new Persona();
        <>g__initLocal2.Nombre = "Leonardo";
        <>g__initLocal2.Apellido = "Micheloni";
        <>g__initLocal0.Add(<>g__initLocal2);
        Persona <>g__initLocal3 = new Persona();
        <>g__initLocal3.Nombre = "Enzo";
        <>g__initLocal3.Apellido = "Francescoli";
        <>g__initLocal0.Add(<>g__initLocal3);
        Persona <>g__initLocal4 = new Persona();
        <>g__initLocal4.Nombre = "Ariel";
        <>g__initLocal4.Apellido = "Ortega";
        <>g__initLocal0.Add(<>g__initLocal4);
        List<Persona> personas = <>g__initLocal0;
        personas.Sort(delegate (Persona x, Persona y) {
            return x.Apellido.CompareTo(y.Apellido);
        });
        personas.ForEach(new Action<Persona>(Console.WriteLine));
    }
}

En las líneas remarcadas vemos que efectivamente el compilador creó el mismo delegado que habíamos definido en el primer ejemplo, sólo que nuestro código quedó mucho mas bonito y compacto gracias a las expresiones Lambda.

Hasta la próxima.

Cómo iniciar varios proyectos a la vez con Visual Studio

2008-08-08T09:33:00.004-03:00

Cómo correr dos aplicaciones a la vez desde Visual Studio

Una vez más algo que surge de mis experiencias diarias, esto viene a cuenta de tener una aplicación cliente y otra servidor que por motivos de prolijidad están dentro de la misma solución, el problema es que para depurar ambas de modo simultáneo se hacian cosas poco felices como abrir dos Visual Studio, bueno, hay una forma de hacerlo bien.

Cómo indica a Visual Studio que ejecute varias aplicaciones de modo simultáneo

El truco (o la forma correcta de hacerlo) es más que sencilla, vamos a ver.

Primero que nada vamos a pararnos en el explorador de soluciones y hacer botón derecho sobre el nodo de la solución, es ese momento vemos la siguiente pantalla

Al ir a la propiedades vamos a ver esto

Justamente en la opción starup project hay una opción que dice "multiple starup project" y para los que no saben Inglés es algo como "inicio de múltiples proyectos....con un poco de astucia sabemos que estamos ante la solución.

Dentro de las opciones de "iniciar múltiples proyectos" Dentro de las opciones de "iniciar múltiples proyectos" podemos indicarle a Visual Studio cómo iniciar los proyectos, con las siguientes acciones

None: No hace nada

Start: Inicia en modo debug

Start without debugging: Inicia pero sin la posiblidad de depurar.

Mágico, y simple, hasta la próxima.

[VIDEOS] Introducción a SCRUM

2008-07-21T09:14:00.001-03:00

De la mano del gran Juán Gabardini les dejo estos dos videos introducción a SCRUM, muy interesantes y simples para que no digan que no tienen idea de lo que es, saludos

Introducción de SCRUM en 15 minutos

[VIDEO] Introducción muy introducción a NHibernate

2008-07-16T20:05:00.006-03:00

Este es el primero de espero muchos videos acerca de NHibernate, celebrando la beta1 de la versión 2 del framework.
En este caso tenemos un video más que introductorio como para "ver" qué onda, vamos a ir agregando conceptos con otros post y con teoría, mientras tanto dejor el video y algunos links interesantes

El video en Youtube

Sitio de NHibernate
NHibernate Hispano
Blog de Darío Quintana
Link para bajar el video (27608KB)

Introducción a Unity, o inyección de dependencias parte dos

2008-07-15T10:36:00.000-03:00

Cómo utilizar Unity?

A pesar que tenía en mente seguir el tema de IoC/ Inyección de dependencias con Microkernel a pedido del público voy a mostrar cómo lograr lo mismo que con Windsor pero con Unity, la ventaja de Unity es que podemos lograr todo lo que se logra por configuración programáticamente (es decir por código), pero como a veces son mejores los ejemplos y no tengo ganas de escribir dejo el famoso código autodescriptivo.

namespace PruebaUnity
{
    [TestFixture]
    public class UnityTestFixture
    {
        Microsoft.Practices.Unity.UnityContainer container = new Microsoft.Practices.Unity.UnityContainer();

        /// <summary>
        /// Una diferencia entre Unity y otros framewoks (Windsor, Springs) es que puede resolver tipos
        /// que no se encuentren registrados
        /// </summary>
        [Test]
        public void ResolverTipo()
        {
            //FakeDbConnection no se encuentra registrada, sin embargo Unity intenta resolverla
            //y lo loga sin necesidad de hacer nada
            IDbConnection conneccionNoRegistrada = container.Resolve<FakeDbConnection>();
            Assert.IsNotNull(conneccionNoRegistrada);
        }

        [Test]
        public void CrearObjeto()
        {
            container.RegisterType<IDbConnection, FakeDbConnection>();

            IDbConnection connection = container.Resolve<IDbConnection>();
            Assert.IsNotNull(connection);
        }

        [Test]
        public void ResolverTipoConDependencias()
        {
            container.RegisterType<IDbConnection, FakeDbConnection>();

            //cuando intente crear un objeto ProcessorImp va a encontrar que depende de algún
            //tipo que implemente IDbConnection y va a intentar resolverlo, como ya hemos 
            //registrado FakeDbConnection que implementa IDbConnection se lo inyectará
            IProcessor processor= container.Resolve<ProcessorImp>();

            Assert.IsInstanceOfType(typeof(FakeDbConnection),processor.Connection);            
        }

        [Test]
        public void RegistrarSingleton()
        {
            container.RegisterType<IDbConnection, FakeDbConnection>(
                new Microsoft.Practices.Unity.ContainerControlledLifetimeManager());

            IDbConnection connection = container.Resolve<IDbConnection>();

            IDbConnection connection2 = container.Resolve<IDbConnection>();

            //verificamos que se trate del mismo objeto en memoria
            Assert.AreSame(connection, connection2);
        }

        [Test]
        public void InyectarDependencias()
        {
            string connectionString = @"Data Source=.\SQL2005;Initial Catalog=KK;User ID=sa";

            container.RegisterType<IDbConnection, FakeDbConnection>();

            //indicamos que cuando se intente resolver un tipo ProcessorImp
            //se debe inyectar un valor en la propiedad ConnectionString

            container.Configure<Microsoft.Practices.Unity.InjectedMembers>()
                .ConfigureInjectionFor<ProcessorImp>(
                new Microsoft.Practices.Unity.InjectionProperty("ConnectionString", connectionString));

            IProcessor processor = container.Resolve<ProcessorImp>();

            Assert.IsInstanceOfType(typeof(FakeDbConnection), processor.Connection);
            Assert.AreEqual(processor.Connection.ConnectionString, connectionString);
        }
    }

    public class FakeDbConnection : IDbConnection
    {
        public IDbTransaction BeginTransaction(IsolationLevel il)
        {
            throw new NotImplementedException();
        }

        public IDbTransaction BeginTransaction()
        {
            throw new NotImplementedException();
        }

        public void ChangeDatabase(string databaseName)
        {
            throw new NotImplementedException();
        }

        public void Close()
        {
            throw new NotImplementedException();
        }

        private string _connectionString;

        public string ConnectionString
        {
            get
            {
                return _connectionString;
            }
            set
            {
                _connectionString = value;
            }
        }

        public int ConnectionTimeout
        {
            get { throw new NotImplementedException(); }
        }

        public IDbCommand CreateCommand()
        {
            throw new NotImplementedException();
        }

        public string Database
        {
            get { throw new NotImplementedException(); }
        }

        public void Open()
        {
            throw new NotImplementedException();
        }

        public ConnectionState State
        {
            get { throw new NotImplementedException(); }
        }

        public void Dispose()
        {
            throw new NotImplementedException();
        }
    }

    public class ProcessorImp : IProcessor
    {
        IDbConnection _connection;

        public ProcessorImp(IDbConnection connection)
        {
            _connection = connection;
        }
        public void Process()
        {
            //llama a _connection y hace algo... 
        }

        public IDbConnection Connection
        {
            get { return _connection; }
        }

        public string ConnectionString
        {
            get
            {
                return this.Connection.ConnectionString;
            }

            set
            {
                this.Connection.ConnectionString = value;
            }
        }
    }

    public interface IProcessor
    {
        void Process();

        IDbConnection Connection
        {
            get;
        }
    }

}

Sencillo y claro, hasta la próxima.

Home page de Unity

Depurando servicios de Windows del modo fácil

2008-07-08T15:44:00.004-03:00

¿Cómo puedo "atachar" facilmente un servicio de windows para depurarlo?

La forma clásica es tener el servicio corriendo y presionando Ctrl + Alt + P buscar el proceso en la ventanita y asociarlo con el código, esto es especialemente molesto en caso de neceistar que el servicio no haga nada antes de encontrarse "atachado" y sobre todo para encontrar un buen lugar donde poner el punto de interrupción, bien , hay una forma más sencilla.

System.Diagnostic. Debugger un amigo

Dentro de las muchas clases que hay dentro de este espacio de nombre se encuentra la buena de Debugger, si somos un poco avispados nos podemos dar cuenta de su fución: es para depurar, dentro de sus métodos hay uno que nos va a ayudar en este caso, Launch(), este método va a lanzar el "debugger" de .net inmediatamente, fantástico, ahora el tema es cómo hacer para lanzarlo en el servicio y no siempre, bueno, veamos.

¿Cómo leer los parámetros de línea de comando de un servicio de Windows?

Fácil, dentro del método Start del servicio llegan los parámetros, o sea, lo único que deberíamos hacer es leer un parámetro que lo podemos llamar "DEBUG" para ser astudos y en caso de llegar llamar a Debugger.Lanuch() y listo, vamos a ver cómo

namespace MiServicioLoco
{
    public partial class ServicioLoco : ServiceBase
    {
        public ServicioLoco()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Este método se ejecuta cuando se inicia el servicio
        /// </summary>
        /// <param name="args"></param>
        protected override void OnStart(string[] args)
        {
            //los parámetros que se envían desde la ventana de propiedades del servicio
            //entren por acá

            //en caso de que el primer parámetro de línea de comando sea igual a DEBUG
            //se lanza el debugger
            if (args.GetLength(0) > 0 && args[0].Equals("DEBUG"))
                System.Diagnostics.Debugger.Launch();
                
            //ahora podemos continuar con el proceso atachado

        }

        protected override void OnStop()
        {
            // TODO: Add code here to perform any tear-down necessary to stop your service.
        }
    }
}

Grandioso, ahora lo único que debemos hacer es

para pasar el parámetro al serivico y mágicamente se lanzará la ventana

Mágico, seleccionamos el debugger (el VS) y listo, que mejore vuestra depuración....saludos.

Qué es la inversión de control / inyección de dependencias e intruducción a Windsor Container

2008-07-03T12:34:00.002-03:00

Inyección de dependencias.

Vamos a introducirnos en un algo importante y además muy interesante, la inyección de dependencias y la inversión de control.

Ambos patrones se encuentran muy asociados, tanto que es normal confundirlos, para hacerlo claro, inversión de control es el modo en que funcionan generalmente los frameworks, en lugar de nosotros instanciar un objeto Database en el data access application block de Enterprise Library le decimos a la clase DatabaseFactory que lo haga por nosotros, es es inversión de control, en lugar de tener nosotros el control sobre la creación de objetos le pedimos alguien más que lo haga. Inyección de dependencias es cuando un objeto A depende de uno B, esta dependencia es inyectada al objeto A por el constructor por ejemplo, es decir, el objeto A tiene un constructor que acepta un parámetro del tipo objeto B, esto es inyectar una dependencia.

Para poder entender el por qué de todo esto vamos a remitirnos a un ejemplo:

El problema:

public interface IProcessor
{ 
    void Process(); 
}

public class ProcessorImp : IProcessor
{
    IDbConnection _connection;
    public ProcessorImp()
    {
        _connection = new System.Data.OleDb.OleDbConnection();
    }
    public void Process()
    {
        //llama a _connection y hace algo... 
        _connection.Open();
    }
}

Si miramos con detenimiento el método Process vemos algo interesante, imaginemos que queremos probar nuestro ProcessorImp y nos encontramos que en el constructor se instancia _connection, por lo tanto, para correr una prueba vamos a necesitar acceder a la base de datos, eso definitivamente no es deseable y mucho menos práctico para una prueba unitaria, pero ¿cuál es la solución?

La solución, inyectar dependencias:

La forma de solucionar esto es de alguna manera evitar que se instancie _connection dentro de ProcessorImp y utilizarlo en forma transparente de modo que podamos, en caso de probarlo, utilizar una implementación de _connection que no acceda a la base de datos, o sea, un Stub o por qué no un Mock.

Primera aproximación, desacoplar con interfaces

La inyección de dependencias es algo tan simple como evitar que nuestros objetos de negocios creen objetos que necesitan utilizar, proveyéndoselos ya listos para operar. ¿Y cómo hacemos esto? Inyectándolos.

Hay un par de formas de inyectar dependencias, pero nosotros vamos a elegir la inyección de dependencias por constructor (ya que no tiene sentido que exista la clase Processor sin un IDbConnection), que no es más que pasarle a nuestro objeto de negocios ese objeto que necesita ya listo a través de su constructor, más aún, vamos a pasarle una interfaz lo cual nos va a traer otras ventajas adicionales, vamos a ver cómo queda el código con esta modificación:

public class ProcessorImp : IProcessor
{
    IDbConnection _connection;
    public ProcessorImp(IDbConnection connection)
    {
        _connection = connection;
    }
    public void Process()
    {
        //llama a _connection y hace algo... 
    }
}

Un poco mejor, vemos que estamos pasando el IDbConnection en el constructor, lo cual es bueno porque nos va permitir pasarle cualquier cosa que implemente esta interfaz y simule el comportamiento de la capa de datos en caso de querer probarlo en una prueba unitaria. Ahora bien, para construir un objeto IProcessor antes hacíamos:

IProcessor processor = new ProcessorImp();

Pero ahora no podemos porque el constructor de ProcessorImp (la única clase que tenemos que implementa IProcessor) en su lugar tenemos que hacer esto:

IDbConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["default"] .ConnectionString); 
IProcessor processor = new ProcessorImp(connection);

Para simplemente después hacer

processor.Process();

O sea, 1 línea útil y 2 inútiles (para la finalidad de la lógica de negocios), esto puede agravarse en caso de tener más de una dependencia de inyectar o que la dependencia que inyectamos a su vez tenga otras dependencias.

Entonces, ¿cómo se resuelve?, fácil, echando mano de otro patrón de diseño Factory para realizar la inversión de control.

El patrón Factory

Nos va a permitir recuperar objetos listos para ser utilizados, sin necesidad de saber nada de ellos, ni de qué dependen, si necesitan información de configuración, etc.

Mágico, si pero ¿cómo hacemos?, veamos un poco de código:

public class ProcessorFactory
{
    public static IProcessor BuildProcessor() 
    { 
        return new ProcessorImp(
            new System.Data.SqlClient.SqlConnection( ConfigurationManager.ConnectionStrings["default"] .ConnectionString); 
    }
}

A esto le llamamos inversión de control (IoC) y es justamente eso, en lugar de decidir nosotros cómo crear un objeto hacemos que alguien más decida por nosotros, o sea, invertimos el control, se usa así:

IProcessor processor = ProcessorFactory.BuildProcessor(); 
processor.Process();

Lindo, ahora la creación del objeto no interfiere con la lógica de negocios y no necesitamos saber nada del objeto que vamos a utilizar, no limitamos a saber de la interfaz. Mejorando las pruebas unitarias Esta forma de hacer las cosas nos permite mejorar las pruebas unitarias ya que para probar el ProcessorImp, simplemente creamos un Factory que nos dé un ProcessorImp y le inyecte por constructor una IDbConnection que no haga nada o que haga lo que necesitamos para la prueba más o menos así:

public class ProcessorFakeFactory
{
    public static IProcessor BuildProcessor()
    {
        return new ProcessorImp(new FakeDbConnection());
    }
}

Algo mejor sería hacerlo con un framework de Mock como RhinoMocks o el increíble Moq del amigo Kzu.

Otras ventajas de la inversión de control

Otra de las ventajas que tenemos utilizando este diseño es que podemos obtener diferentes implementaciones de IProcessor sin hacer mucho y lo más importante, sin impactar en el código de lógica de negocios. Si recuerdan algo que dije antes, en la interfaz no se encuentra el constructor y esto nos permite con la misma interfaz utilizar indistintamente diferentes implementaciones de IProcessor que pueden tener otras dependencias, por ejemplo:

public class ProcessorFakeFactory
{
    public static IProcessor BuildProcessor()
    {
        return BuildProcessor(ProcessorType.Sql);
    }
    public static IProcessor BuildProcessor(ProcessorType type)
    {
        switch (type)
        {
            case ProcessorType.Sql:
                return new ProcessorImp(
                    new System.Data.SqlClient.SqlConnection(
                    ConfigurationManager.ConnectionStrings["default"].ConnectionString));
                break;
            case ProcessorType.OleDb:
                return new ProcessorImp(
                    new System.Data.OleDb.OleDbConnection(
                    ConfigurationManager.ConnectionStrings["oledb"].ConnectionString));
                break;
            default:
                throw new ArgumentException("type"); break;
        }
    }
    public enum ProcessorType
    {
        Sql,
        OleDb
    }
}

Esta implementación es más o menos lo que hace DataAccess Application Block cuando hacemos DataBaseFactory.CreateDataBase() con una agregado que veremos más adelante.

Se ve claramente las ventajas de éste modelo, disminuimos el acoplamiento, mejoramos las pruebas unitarias, obtenemos mayor flexibilidad y queda lindo.

Ahora si, framework de inversión de control

El siguiente paso en todo esto es utilizar un framework de inyección de dependencias que haga la inversión de control, y en el mundo de .net hay para todos los gustos, vamos a enumerarlos:

Spring.net: es un port del famoso framework de Java
Windsor container: parte del proyecto Castle, muy extendido
Unity: de patterns & practices de Microsoft, basado en ObjectBuilder que es lo que utiliza internamente DataAccess Application Block
Ninject: Este es nuevito, la principal característica es que se basa en atributos para saber qué y cómo inyectar.

¿Cómo funcionan los frameworks de IoC?

Los framework de IoC nos permite tener un repositorio (en realidad es transparente el repositorio lo maneja el framework, de echo vamos a utilizar el término repositorio para referirnos a él) donde tenemos nuestros objetos e ir pidiéndoselos, algunas ventajas adicionales, como controlar el ciclo de vida de los objetos, crearlos tipo singleton, reutilizar instancias, y resolver dependencias anidadas, como tener un objeto A configurado y pedirle un B y que sólo se dé cuenta que necesita A y crearlos según lo configurado.

Basados en archivos de configuración

Hay variantes entre estos que enumeramos, la más utilizada es basarse en un archivo de configuración para saber cómo crear los objetos, a mí, personalmente no me gusta porque cuando tenemos una aplicación con varios (no digo mucho, 30 nomás) objetos se pone bastante molesto el archivo de configuración, a esto hay que sumarle que en caso de necesitar comprender algunas cosas sobre estos objetos tenemos que “bucear” el archivo de configuración, y no anda el intellisense ;-).

Basados en declaración programática

Casi todos, los frameworks soportan definir los objetos por medio de código, esto puede parece poco ventajoso, en lugar de escribir una sintaxis especial para instanciar los objetos escribo todo de forma normal y listo, pero nos perdemos el manejo del ciclo de vida que hace el framework.

Basados en atributos

El chico nuevo de la cuadra es Ninject que se basa en atributos para la definición de las dependencias, cero configuración, simplemente agregamos atributos a nuestras clases y listo, mágico, la idea es muy interesante aunque no me gusta mucho la implementación por motivos que vienen al caso.

Ahora sí, un ejemplo con un framework de IoC

Dentro de los frameworks que he nombrado los que más me agradan son Unity y Windsor (ya sé que me contradigo), vamos a ver unos ejemplos introductorios con Windsor ya que es simple y es bueno conocerlo.

Windsor container

También conocido como microkernel porque en realidad se basa en él y lo extiende, es parte del proyecto castle que si no lo conocen les recomiendo una vuelta. En él se basan muchos otros proyectos, como NHibernate, Moq, Rhino, etc. Diría sin temor a equivocarme que es el más extendido en la comunidad .net.

Antes que nada vamos a necesitar descargarlos desde acá .Y referenciar estos assemblies

Castle.Core.dll
Castle.MicroKernel.dll
Castle.Windsor.dll
Castle.DynamicProxy.dll

El código para configurar el contenedor es éste

IWindsorContainer container = new WindsorContainer(); 
container.AddComponent("Sql", typeof(IDbConnection), typeof(System.Data.SqlClient.SqlConnection)); 
container.AddComponent("Processor", typeof(IProcessor), typeof(ProcessorImp));

Y para utilizarlo

IProcessor processor = container.Resolve<IProcessor>();

La idea es poner todo esto dentro del Factory o en alguna inicialización de nuestro objeto aplicación o no, es una discusión de arquitectura que no viene al caso.

Más flexibilidad con Windsor

Seguramente se están preguntando dos cosas:

Cómo le paso el parámetro del connectionString a SqlConnection
Cómo hago en caso de tener más de una implementación de IDbConnection para indicarle al contenedor cuál utilizar para crear el IProcessor

Excelentes preguntas, la respuesta para todas es: no se puede por código, esta flexibilidad sólo está disponible si configuramos el contenedor por archivo de configuración. De la siguiente forma:

Utilizando Windsor desde archivo de configuración

IWindsorContainer container = new WindsorContainer( 
    new XmlInterpreter(new ConfigResource("castle")));
IProcessor processor = container.Resolve();

Esto con relación al código, le indicamos al contenedor que obtenga la configuración desde la sección “castle” del archivo de configuración. El archivo de configuración queda así:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data, Version=3.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
        <!--de esta manera le indicamos al motor de configuración que vamos a utilizar una sección llamanda castle
        que se parsea a partir del tipo CastleSectionHandler que se encuentra en el assemblie Castle.Windsor-->
        <section 
           name="castle"
           type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />
    </configSections>
    <!--y esta es la sección de configuración de castle-->
    <castle>
        <components>
            <!--cada elemento que queremos registrar en el contenedor se define dentro de un tag component-->
            <!--en el tag id se coloca el nombre con el que queremos identificar este componente particular-->
            <!--en el tag service la interface-->
            <!--en el tag type el tipo concreto que querems que el contenedor devuelva-->
            <component 
                id="Sql" 
                service="System.Data.IDbConnection, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
                type="System.Data.SqlClient.SqlConnection, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
                <parameters>
                    <!--Windsor busca el constructor que tenga este parámetro y se lo inyecta-->
                    <connectionString>Database=Database;Server=(local)\SQLEXPRESS;Integrated Security=SSPI</connectionString>
                </parameters>
            </component>
            <component 
                id="OleDb" 
                service="System.Data.IDbConnection, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
                type="System.Data.OleDb.OleDbConnection, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
            </component>
            <component 
                id="Processor" 
                service="Tipos.IProcessor, Tipos" 
                type="Tipos.ProcessorImp, Tipos" >
                <parameters>
                    <connection>${Sql}</connection>
                </parameters>
            </component>
        </components>
    </castle>
    <connectionStrings>
        <add name="Sql" connectionString="Database=Database;Server=(local)\SQLEXPRESS;Integrated Security=SSPI"
            providerName="System.Data.SqlClient" />
    </connectionStrings>
</configuration>

Como vemos en la sección “components” definimos nuestros componentes, dentro de cada elemento “component” tres atributos:

Id: El nombre con el que identificamos unívocamente ese componente.
service: El servicio, o sea la interfaz o el tipo con el que vamos a invocar nuestro componente, es decir, cuando le digamos dame un IAlgo ese es el servicio.
type: El tipo concreto que queremos que devuelva cuando se solicite un servicio

Con esto es suficiente, ahora para poder inyectarle parámetros en los constructores tenemos el elemento “parameters” dentro de él colocamos un elemento por cada parámetro del constructor que queremos que el contener invoque, él sólito se va a dar cuenta qué constructor llamar.

¿Cómo se decide qué implementación de un servicio quiero?

Utilizando el tag “parameters” ponemos el nombre del parámetro y luego con un poco de sintaxis “castle” le indicamos qué implementación queremos que le inyecte por el “id” como en el ejemplo, diciendo algo como: cuando te pida IProcessor dame el tipo IProcessorImp y a su constructor que pide un IDbConnection pasale la implementación que tiene el "id" Sql.

Conclusión:

En una palabra, mágico, la inversión de control + inyección de dependencias + factory + frameworks de inversión de control nos permiten crear aplicaciones menos acopladas, más fáciles de probar, de cambiar, de mantener, definitivamente muy interesante. Hasta la próxima.

Restricciones sobre parámetros objetos con Rhino Mocks

2008-06-18T14:35:00.002-03:00

Restricciones sobre parámetros objetos con Rhino Mocks

Entre las restricciones que nombré en el post anterior se encuentra Property, la misma posee algunos métodos estáticos que nos permiten colocar restricciones a los parámetros de nuestros métodos "moquedos" en caso que sean tipos de referencia (objetos) y quisieramos verificar una condición para una de sus propiedades. Por ejemplo que quisieramos que la propiedad "nombre" del objeto "persona" que es parámetro del método "GuardarPersona" en una clase "moqueada" sea exáctamente "Leonardo" o contenga el texto "Lalo Landa", o incluso que contenga otras restriccions formadas por las otras clases para restricción como Is, Text, etc. vamos diréctamente al código para ver su utilización:

[TestClass]
public class RhinoMocksPropertyConstraint
{
    /// <summary>
    /// Property.Value("nombrePropiedad", "valor")
    /// quiere decir que el valor de la propiedad nombrePropiedad debe
    /// ser valor cuando se utiliza como parámetro de un método "moquedo"
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void PropertyValueConstraint()
    {
        MockRepository mocker = new MockRepository();

        IProcessor mockProcessor = mocker.CreateMock<IProcessor>();

        using (mocker.Record())
        {
            //le decimos al Rhino que la llamada al método debe hacerce
            //con un objeto ClaseParametro cuya propiedad ValorTexto
            //debe tener valor "HOLA"
            Expect.Call(
                mockProcessor.TestMethod(null))
                .IgnoreArguments()
                .Return("")
                .Constraints(Property.Value("ValorTexto", "HOLA"))
                .Repeat.Any();
        }
        //Este assert es correcto, el valor de la propiedad ValorTexto es HOLA
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0, "HOLA")).Length == 0);

        //Lanza una ExpectationViolationExpcetion porque el valor de la propiedad
        //ValorTexto no es "HOLA"
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0, "CHAU")).Length == 0);

        mocker.VerifyAll();
    }
    
    /// <summary>
    /// PropertyValueConstraint permite poner cualquier tipo de constraint
    /// en una propiedad de un objeto que es parámetro de un método "moquedo"
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void PropertyConstraintValueConstraint()
    {
        MockRepository mocker = new MockRepository();

        IProcessor mockProcessor = mocker.CreateMock<IProcessor>();

        using (mocker.Record())
        {
            //le decimos al Rhino que la llamada al método debe hacerce
            //con un objeto ClaseParametro cuya propiedad ValorTexto
            //debe tener contener en su valor ek texto "HOLA"
            Expect.Call(
                mockProcessor.TestMethod(null))
                .IgnoreArguments()
                .Return("")
                .Constraints(Property.ValueConstraint("ValorTexto", Text.Contains("HOLA")))
                .Repeat.Any();
        }
        //Este assert es correcto, el valor de la propiedad ValorTexto contiene la palabra HOLA
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0, "HOLA MUNDO")).Length == 0);

        //Lanza una ExpectationViolationExpcetion porque el valor de la propiedad
        //ValorTexto no contiene "HOLA"
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0, "CHAU")).Length == 0);

        mocker.VerifyAll();
    }

    /// <summary>
    /// IsNull, el objeto parámetro del método "moquedo" deber ser null
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void PropertyConstraintIsNullConstraint()
    {
        MockRepository mocker = new MockRepository();

        IProcessor mockProcessor = mocker.CreateMock<IProcessor>();

        using (mocker.Record())
        {
            //le decimos al Rhino que la llamada al método debe hacerce
            //con un parámetro null
            Expect.Call(
                mockProcessor.TestMethod(null))
                .IgnoreArguments()
                .Return("")
                .Constraints(Property.IsNull("ValorTexto"))
                .Repeat.Any();
        }
        //Este assert es correcto, el parámetro es null
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0,null)).Length==0);

        //Lanza una ExpectationViolationExpcetion porque el valor de la propiedad
        //no es null
        Assert.IsTrue(mockProcessor.TestMethod(new ClaseParametro(0, "")).Length == 0);

        mocker.VerifyAll();
    }
}



public interface IProcessor
{
    string TestMethod(ClaseParametro parametro);
}

public class ClaseParametro
{
    private int _valorEntero;
    private string _valorTexto;

    public ClaseParametro(int valorEntero, string valorTexto)
    {
        this.ValorEntero = valorEntero;
        this.ValorTexto = valorTexto;
    }

    public string ValorTexto
    {
        get { return _valorTexto; }
        set { _valorTexto = value; }
    }


    public int ValorEntero
    {
        get { return _valorEntero; }
        set { _valorEntero = value; }
    }

}

Simple, hay algunos métodos más en esta clase pero creo que no vale la pena explicarlos ya que son muy intuítivos, saludos.

Restricciones con Rhino Mock 3.4 o Constraints en Rhino Mocks, o cómo limitar los valores de los parámetros con mock objects

2008-06-16T23:01:00.002-03:00

Rhino Mocks Constraints o restricciones en Rhino Mocks 3.4
Otra de las características interesantes de un framework de mock es la posiblidad de poner restricciones a los valores que pueden recibir los parámetros de un objeto que estamos "moqueando", esto es, que nuestra Expectation permite definir que el método sólo pueda ser llamado con ciertos valores en sus parámetros, por ejemplo que un parámetros sea exáctamente 2 o mayor de 5 y mucho más.

Tipos de restricciones en Rhino Mocks

Básicamente tenemos cuatro clases con métodos estáticos para trabajar con restricciones:

Is : permite establecer restricciones del tipo "igual a" "mayor que"
Property: para trabajar con propiedades, por ejemplo propiedad tal debe tener tal valor
List: para las listas, se pueden poner restricciones a la cantidad de elementos, etc.
Text: para trabajar con texto, por ejemplo poner una validación basada en una expresión regular

En caso de no cumplir con una restricción para un parámetro Rhino nos lanza una bonita ExpectationViolationException, veámos un ejemplo:

[TestClass]
public class UnitTest1
{

    MockRepository _mocker;

    public MockRepository Mocker
    {
        get
        {
            if (_mocker == null)
                _mocker = new MockRepository();
            return _mocker;
        }
    }

    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void ViolacionDeConstraint()
    {
        IProcessor mockProcessor = Mocker.CreateMock<IProcessor>();
        
        using (Mocker.Record())
        {
            //grabamos un comportamiento que dice que se espera
            //una llamada el método Test en la cual el argumento
            //debe ser mayor a 3
            Expect.Call(mockProcessor.Test(0)).
                Return(true).
                Constraints(Is.GreaterThan(3));
        }

        using (Mocker.Playback())
        {
            //funciona porque devuelve true en caso de llamar al métod
            //con un parámetro mayor que 3
            Assert.IsTrue(mockProcessor.Test(4));
            //Lanza una ExpectationViolationException porque el parámetro
            //viola el constraint
            Assert.IsTrue(mockProcessor.Test(2));            
        }
    }
}

public interface IProcessor
{
    bool Test(int value);
}

Para terminar, los remito a la documentación para conocer todas las restricciones, saludos.

"Moqueando" clases abstractas con Rhino Mocks

2008-06-09T16:43:00.003-03:00

Una interesante funcionalidad de RhinoMocks es la posiblidad de crear instancias de clases abstractas y utilizar sus método concretos sin más que la ayuda de los PartialMocks, incluso podemos dar comportamiento a sus métodos abstractos, con los cual es posible probar una clase abstracta en su totalidad sin tener una implementación concreta, vamos a ver en el famoso código autodescriptivo.

[TestClass]
public class UnitTest1
{
    MockRepository _repository;
    public MockRepository Mocker
    {
        get
        {
            if (_repository == null)
                _repository = new MockRepository();
            return _repository;
        }
    }
    /// <summary>
    /// Los PartialMocks nos permiten crear instancias de clases abstractas
    /// para poder probar los métodos concretos con su implementación real
    /// sin necesidad de heredar en una clase concreta
    /// </summary>
    [TestMethod]
    public void PartialMockTest()
    {
        //se pueden crear instancias de clases abstractas para utlizar los
        //métodos concretos
        AbstractProcessor processor = Mocker.PartialMock<AbstractProcessor>();

        //y funciona :-)
        Assert.AreEqual<string>("Hola Leonardo", processor.Saludar("Leonardo"));
    }

    /// <summary>
    /// No podemos modificar el comportamiento de método concreto
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void PartialMockConfigurarComportamientoMetodoConcreto()
    {
        AbstractProcessor processor = Mocker.PartialMock<AbstractProcessor>();

        using (Mocker.Record())
            Expect.Call(processor.Saludar("")).Return("Método modificado").IgnoreArguments();

        //utilizo la sintáxis de Record-Playback en lugar de ReplayAll-VerifyAll
        using (Mocker.Playback())
            Assert.AreEqual<string>("Método modificado", processor.MetodoUno());
    }

    /// <summary>
    /// También podemos configurar el comportamiento
    /// de los métodos abstratos y concretos
    /// </summary>
    [TestMethod]
    public void PartialMockConfigurarComportamientoMetodoAbstracto()
    {
        //se pueden crear instancias de clases abstractas para utlizar los
        //métodos concretos
        AbstractProcessor processor = Mocker.PartialMock<AbstractProcessor>();

        using (Mocker.Record())
            Expect.Call(processor.MetodoUno()).Return("Metodo1 moqueado");

        //utilizo la sintáxis de Record-Playback en lugar de ReplayAll-VerifyAll
        using (Mocker.Playback())
            Assert.AreEqual<string>("Metodo1 moqueado", processor.MetodoUno());
    }
}

/// <summary>
/// Una clase abstracta no se puede instanciar directamente
/// </summary>
public abstract class AbstractProcessor
{
    //método abstracto, sin implementaci´n
    public abstract string MetodoUno();
    //método concreto, para usarlo es necesario heredar esta clase
    public string Saludar(string nombre)
    {
        return string.Format("Hola {0}", nombre);
    }
}

Interesante, utilizalo con sabiduría, saludos

Diferentes tipos de Mock Objects con Rhino Mocks

2008-06-08T23:27:00.004-03:00

Rhino Mocks nos permite crear diferentes tipos de Mock Objetcts según nuestras necesidades, en total son 3 Mocks, Dynamic Mocks y Stubs, simplemente vamos a ver un ejemplo autodescriptivo, para ver los tres tipos y sus aplicaciones.

[TestClass]
public class UnitTest1
{
    MockRepository _repository;

    MockRepository Mocker
    {
        get
        {
            if (_repository == null)
                _repository = new MockRepository();
            return _repository;
        }
    }

    /// <summary>
    /// Los mock dynamic no verifican la llamada a ningún tipo de métod
    /// sirven por ejemplo para configurar respuestas a métodos pero no verificar
    /// si son llamados
    /// </summary>
    [TestMethod]
    public void DynamicTest()
    {
        IDummy MockDummy = Mocker.DynamicMock<IDummy>();

        Expect.Call(MockDummy.DummyMethod("")).Return("hola");

        Mocker.ReplayAll();

        //se retorna el valor configurado
        Assert.AreEqual("hola",MockDummy.DummyMethod(""));

        //nada me impide llamar varias veces a un método a pesar de no encontrase
        //configurado para ello, sin embargo no retorna el valor configurado
        Assert.AreEqual(null, MockDummy.DummyMethod(""));

        Mocker.VerifyAll();
    }

    /// <summary>
    /// Un mock (Strict replay)
    /// verifica que se llamen a los métodos esperados y sólo a estos
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void MockLlamadaMetodoNoEsperado()
    {
        IDummy MockDummy = Mocker.CreateMock<IDummy>();
        
        Mocker.ReplayAll();

        //lanza una excepción de uso inválido porque se llama a un método que no se esperaba
        MockDummy.DummyMethod("");

        Mocker.VerifyAll();
    }
    /// <summary>
    /// Un mock (Strict replay)
    /// verifica que se llamen a los métodos esperados y sólo a estos
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(ExpectationViolationException))]
    public void MockNoSeLlamoEsperado()
    {
        IDummy MockDummy = Mocker.CreateMock<IDummy>();
        Expect.Call(MockDummy.DummyMethod("")).Return(null);

        Mocker.ReplayAll();

        //lanza una excepción de uso inválido porque no se llamó a un método esperado
        Mocker.VerifyAll();
    }

    /// <summary>
    /// Un stub no tiene comportamiento, es útil para crear objetos
    /// que necesitamos para hacer funcionar otros pero de los que 
    /// no esperamos ningún comportamiento
    /// </summary>
    [TestMethod]
    public void StubTest()
    {
        IUsuario usuario = Mocker.Stub<IUsuario>();

        Mocker.ReplayAll();

        //el stub se comporta como un objeto con propiedades
        usuario.Nombre = "leonardo";

        Assert.AreEqual<string>("leonardo", usuario.Nombre);

        Mocker.VerifyAll();
    }

    /// <summary>
    /// Un stub no tiene comportamiento, es útil para crear objetos
    /// que necesitamos para hacer funcionar otros pero de los que 
    /// no esperamos ningún comportamiento
    /// </summary>
    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void StubNoAceptaComportamientoTest()
    {
        IUsuario usuario = Mocker.Stub<IUsuario>();
        //el stub no acepta comportamiento, lanza una excepción acá
        Expect.Call(usuario.ToString()).Return("usuario");

        Mocker.ReplayAll();

        usuario.Nombre = "leonardo";

        Assert.AreEqual<string>("leonardo", usuario.Nombre);

        Mocker.VerifyAll();
    }
}

Sencillo, hasta la próxima

Cómo poner constraints en método genéricos

2008-05-28T14:53:00.002-03:00

Una de las cosas que me olvidé de nombrar en el post sobre generics es cómo poner un constaint para un método, bueno, por ahora eso sólo así que acá está

Como poner un constraint a un método

public void Probar<T>(T param) where T : IBase
{
}

En este código simplemente decimos que el tipo T del parámetro param debe implementar la interfaz IBase, esto hasta la próxima.

Actualización

Como indica mi colega Eduardo el ejemplo que puse es muy malo, en realidad casi no sirve para nada, en casos muy raros que si bien se me ocurren son muy confusos, veámos casos en los que un constraint es útil en un método

Tipos de restricciones

Vamos a ver tres casos en los que las restricciones pueden ser útiles en los métodos

/// <summary>
/// new() indica que T tiene que tener un constructor sin parámetros
/// </summary>
public void Probar2<T>(T param) where T : new()
{
    //Si quito la restrucción no puedo hacer esto 
    //porque T no tiene implícitamente un constructor sin parámetros
    T var = new T();
}

/// <summary>
/// class indica que T será un tipo por referencia
/// </summary>
public void Probar3<T>(T param1, T param2) where T : class
{            
}

/// <summary>
/// struct indica que T tiene que se un tipo no Nullable
/// </summary>
public void Probar4<T>(T param1, T param2) where T: struct
{
    //Si quito la restricción no puedo hacer esto
    //porque el método Nullable.Compare espere dos tipos nos nullables (underlying types)
    //sin embargo se pueden pasar estructuras
    Nullable.Compare<T>(param1, param2);
}

Bueno, espero que les sirva y gracias Eduardo por la observación

Pruebas manejadas por datos con VIsual Studio o Data Driven Test

2008-05-22T10:34:00.004-03:00

Pruebas manejadas por datos con Visual Studio

Un utilidad interesante del Visual Studio es la posibilidad de que un método de prueba (TestMethod) se ejecute múltiples veces a partir de un origen de datos, qué quiero decir con esto, teniendo un origen de datos (SqlServer, Access, Oracle, Excel, cualquier cosa que tenga un conector .net) podemos hacer que el IDE de Visual Studio ejecute un método de prueba (un TestMethod) una vez por cada registro de un origen de datos.
Por ejemplo, podemos tenes un método para probar un cierto algorítmo pero como no podemos tener todos los casos de prueba claro de entemano (quiero decir los posibles datos de entrada) podemos hacer que el método los tome del origen de datos y se ejecute una vez por cada registros, esto nos permite dos cosas:

-Poder dejar para más adelante todos los casos posibles, no pensarlo ahora, o porque no los sabemos o porque no queremos o lo que sea.
-Delegar a otra persona (funcional tal vez) la tarea de crear los datos de entrada e incluso ejecutar la prueba unitaria

Por supuesto, no podemos saber de antemano que van a poner, así que una forma astuta (que obviamente no se me ocurrió a mí) es poner una columna adicional con el resultado esperado, pero bueno, basta, vamos al código

/// <summary>
/// Este método se ejecuta una vez por cada fila de la tabla
/// </summary>
[TestMethod]
[DataSource(
  "System.Data.Odbc", 
    @"Dsn=Excel Files;
    dbq=C:\\Pruebas\\datosPruebaDB\\origenDatos.xls;
        defaultdir=C:\\Pruebas\\datosPruebaDB;
    driverid=790;
    maxbuffersize=2048;
    pagetimeout=5", 
    "Datos$", 
    DataAccessMethod.Sequential)]
public void TestMethod1()
{
   //recuperados los valores del origen de datos
    string valor = this.Context.DataRow["Valor"].ToString();
    bool resultado = Convert.ToBoolean(this.Context.DataRow["Resultado"]);

    //nuestra función de validación de largos
    bool largoCorrecto = (valor.Length>6);

    //assert para verficar si coincide con el resultado esperado
    Assert.AreEqual<bool>(largoCorrecto, resultado);

}

Y listo es todo, es este caso mi archivo Excel tiene esta forma

Valor	Resultado
Leonardo	1
Gabriel	1
Hernán	0
Gerardo	1
Norberto	1
Adrián	0
Angel	0
Albino	0

Lo hice con Excel para que sea más visual, por supuesto, la hoja donde se encutran estos datos se llaman "Datos" y me conecto por ODBC. La columna con el encabezado valor es el valor de entrada y la que se llama resultado es el resultado esperado, como puede verse simplemente agrego un atriburo en el método indicando el origen de datos y después recupero la fila actual con el TestContext.

Enjoy,

Primeras Jornadas Ágiles de Latinoamérica 2008

2008-05-17T00:35:00.004-03:00

El proyecto del cual participo como organizador (realmente mi participación es más que escueta) http://www.agiles.2008.org/ ya es Agile Alliance Compliant http://www.scrumalliance.org/events/10-giles-, felicitaciones al equipo, a Juan, Ricardo y todos los demás. Saludos.