6.19.2009

Podcast Driven Design (PDD)

En conjunto con Carlos Lone de Guatemala, hemos estado trabajando en la creación de una serie de podcast a los que hemos llamado “Podcast Driven Design (PDD)”. En estos programas, tratamos de discutir hacer de las tecnologías para desarrollar aplicaciones .NET y sobre todo tratamos de explicar un poco más a fondo cual es el rol de cada tecnología en nuestras aplicaciones.

Aqui les dejo el primer episodio que hemos grabado. Este episodio es un programa donde se discuten temas como Linq2SQL, Entity Framework  y los ORM’s en general. Espero les guste y esperamos sus comentarios

Episodio # 1 (ORM's y LINQ to SQL)

Descargar

6.14.2009

Versionando Aplicaciones – CastleWindsor – Parte 2

Tal y como lo mencioné en el post pasado, la forma más adecuada para manejar versionamiento de aplicaciones ( diversas funcionalidades por cliente dentro de una aplicación) es utilizando IoC. En este post voy a examinar como manejar el versionamiento utilizando la librería CastleWindsor – Windsor Container - como contenedor de IoC.

Para examinar los tres frameworks de IoC, voy a utilizar el mismos ejemplo. El ejemplo consiste en una interface para manejar alertas, la cual especifica en su contrato una propiedad para almacenar el mensaje y un método para enviar la alerta. Vamos a tener dos clases implementando este contrato, una que teoóricamente envía alertas por email, y otra por SMS. Vamos a tener además una clase para hacer búsquedas la cual enviará una alerta cada vez que se haga una búsqueda ( suponiendo que en la búsqueda van palabras que pueden ser consideras “peligrosas ). El diagrama de clases es el que se presenta a continuación:

image

Utilizando Castle Windsor

El Windsor Container es un contenedor de control de inversión el cual a grandes rasgos, extiende la funcionalidad de su homólogo en el mismo framework – MicroKernel – agregando soporte por configuración.

En este caso vamos a crear una aplicación de consola que contenga las clases y la interface antes mencionada y vamos a instanciar las alertas utilizando el IoC CastleWindsor.

Para poder utilizar CastleWindsor debemos agregar las referencias siguientes:

image

Seguidamente procedemos a crear la interface IAlert, la cual va a tener el contrato de la funcionalidad de la alerta:

image

El código de esta interface es el siguiente:

public interface IAlert
{
string Message { get; set; }
string SendAlert( );
}


El siguiente paso es crear la clase EmailAlert para enviar alertas por correo.



public class EmailAlert : IAlert
{
private string m_Message;

public string Message
{
get
{
return m_Message;
}
set
{
m_Message = value;
}
}

public string SendAlert( )
{
if (!string.IsNullOrEmpty(Message))
return Message;
return "Alerta enviada por mail";
}


}


Ahora vamos a crear la clase SMSAlert para “enviar” alertas a través de SMS.



public class SMSAlert : IAlert
{
private string m_Message;
public string Message
{
get
{
return m_Message;
}
set
{
m_Message = value;
}
}

public string SendAlert( )
{
if (!string.IsNullOrEmpty(Message))
return Message;
return "Enviando Alerta por SMS";
}
}



A continuación vamos a crear la clase SearchManager, la cual es la que realiza las búsquedas y dispara las alertas.



public class SearchManager
{
public IAlert Alert { get; set; }

public SearchManager( IAlert pAlert )
{
Alert = pAlert;
}

public string DoSearch( string criteria )
{
//Notificamos la búsqueda
if (Alert != null)
return Alert.SendAlert( );
return "Error!";
}
}


En primera instancia vamos a registar los componentes a instanciar desde el código ( algo que no tiene mucho sentido si se lo que se desea es versionar, pero es una buena forma de entender como funciona este contenedor). El código siguiente muestra como llevar a cabo esta tarea.



class Program
{
static void Main( string[] args )
{
IWindsorContainer contenedor = new WindsorContainer( );
contenedor.AddComponent("Email.Alert", typeof(IAlert), typeof(EmailAlert));
contenedor.AddComponent("Sms.Alert", typeof(IAlert), typeof(EmailAlert));


IAlert AlertaEnviada = contenedor["Email.Alert"] as EmailAlert;
//IAlert AlertaEnviada = contenedor["Sms.Alert"] as EmailAlert;

Console.WriteLine("Alerta: {0}", AlertaEnviada.SendAlert( ));

}
}



Primeramente, podemos ver que se instancia el contenedor de componentes, seguidamente registramos los componentes que queremos que esten disponibles para el contenedor, y por último instanciamos la clase que deseamos utilizar en el código. Como se puede ver en el proceso de crear la instancia, lo único que tenemos que hacer es pedirle al contenedor que me devuelva una instancia de la clase utilizando la llave que se utilizó para agregar la definición del componente al contenedor – en el ejemplo anterior Email.Alert y Sms.Alert. Al ejecutar la aplicación de consola recién creada obtenemos el siguiente resultado:



image



Seguidamente vamos a llevar a cabo esta instanciación y el registro de componentes via configuración, en donde el manejo versionamiento empieza a tener sentido.



Utilizando Archivos de Configuración


Por supuesto que el registrar componentes vía código, no es la forma en que podemos aprovechar este patrón para poder versionar nuestra aplicación. Lo que realmente buscamos, es poder registrar componentes sin recompilar la aplicación, y que la aplicación compilada busque los servicios en los contratos especificados vía configuración.



Para esto WindsorCastle tiene la posiblidad de registrar los componentes vía archivo de configuración, y al ser la aplicación de ejemplo una aplicación de consola, este archivo es el app.config. Para registrar los componentes vía archivo de configuración, tenemos que agregar los siguientes elementos a este archivo:



<?xml version="1.0" encoding="utf-8" ?>
<
configuration>
<
configSections>
<
section
name="castle"
type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />
</
configSections>
<
castle>
<
components>
<
component
id="Email.Alert"
service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor"
type="PruebaCastleWindsor.EmailAlert, PruebaCastleWindsor" />

<
component
id="Sms.Alert"
service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor"
type="PruebaCastleWindsor.SMSAlert, PruebaCastleWindsor" />
</
components>

</
castle>

</
configuration>


Como podemos ver, primero debemos crear una sección donde se registra el Handler de CastleWidows – llamada castle – y luego en la sección de componentes de castle procedemos a registrar nuestros componentes. En este caso, PruebaCastleWindsor es el namespace que estoy utilizando en la aplicación de ejemplo. Seguidamente procedemos a cambiar el método Main en el archivo Program.cs de la siguiente manera:



using System;
using Castle.Core.Resource;
using Castle.Windsor;
using Castle.Windsor.Configuration.Interpreters;

namespace PruebaCastleWindsor
{
class Program
{
static void Main( string[] args )
{
IWindsorContainer contenedor = new WindsorContainer(new XmlInterpreter(new ConfigResource("castle")));
//IAlert AlertaEnviada = contenedor["Email.Alert"] as EmailAlert;
//IAlert AlertaEnviada = contenedor["Sms.Alert"] as EmailAlert;
IAlert AlertaEnviada = contenedor[typeof(IAlert)] as IAlert;
Console.WriteLine("Alerta: {0}", AlertaEnviada.SendAlert( ));
contenedor.Release(AlertaEnviada);
}
}
}


Primeramente, agregamos las referencias a las librerías necesarias para poder utilizar el contenedor vía configuración, seguidamente creamos la instancia del contenedor pero esta vez, le indicamos que busque el recurso de configuración en la sección llamada “castle”. Por último, invocamos el componente de la misma forma que hicimos en el código anterior, solo que esta vez estamos cargando la instancia por medio del tipo del servicio, igualmente puedo cargar la instancia utilizando la llave utilizada para registrar el componente en el archivo config. Al ejecutar el código anterior, el resultado es:



image Hay varias cosas que se pueden destacar de este resultado. Primero, veamos que la alerta que se envía es la de correo, pero ¿por qué? bueno, esto sucede por que en el archivo de configuración EMailAlert fue el primero componente registrado, y como no le indicamos al contenedor que tipo instanciar, el automáticamente toma el primero en la lista.



<components>



<component id="Email.Alert" service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor" type="PruebaCastleWindsor.EmailAlert, PruebaCastleWindsor" />



<component id="Sms.Alert" service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor" type="PruebaCastleWindsor.SMSAlert, PruebaCastleWindsor" />



</components>



Seguidamente podemos ver que aunque instanciamos un tipo específico, en ningún momento atamos el código con la alerta de correo, ni con la alerta de SMS, por lo que trabajando con los servicios – interfaces – podemos ejecutar la instancia del componente que deseamos.



Seleccionando la Instancia de la Clase que Deseamos Crear


Ahora le vamos a decir al buscador que seleccione vía configuración, como debe enviar la alerta, ya sea por correo o por SMS. Para lograr esto, vamos a registrar la clase SearchManager en los componentes de CastleWindsor, y vamos a crear la instancia desde el contenedor. Primeramente, agregamos SearchManager al conjunto de componentes registrados en CastleWindsor.



<castle>
<
components>
<
component
id="SearchManager"
type="PruebaCastleWindsor.SearchManager, PruebaCastleWindsor"
/>

<
component
id="Email.Alert"
service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor"
type="PruebaCastleWindsor.EmailAlert, PruebaCastleWindsor" />

<
component
id="Sms.Alert"
service="PruebaCastleWindsor.IAlert, PruebaCastleWindsor"
type="PruebaCastleWindsor.SMSAlert, PruebaCastleWindsor" />
</
components>

</
castle>



El siguiente paso, es instanciar la clase SearchManager desde el contenedor y llamar al método DoSearch, que al mismo tiempo, es el método que envía la alerta.



static void Main( string[] args )
{
IWindsorContainer contenedor = new WindsorContainer(new XmlInterpreter(new ConfigResource("castle")));
SearchManager manager = contenedor[typeof(SearchManager)] as SearchManager;
Console.WriteLine(manager.DoSearch("búsqueda"));

}


De nuevo, si ejecutamos este código el resultado va a ser igual al resultado anterior como podemos ver en esta imagen.



image La razón es igual a la anterior, el componente EmailAlert esta registrado primero que el SMSAlert, y como podemos ver en la siguiente imagen, cuando se crea la instancia del SearchManager, CastleWindsor crea una instancia del parámetro que se desea tomando el orden de registro del componente, en este caso, tomando la clase EmailAlert.



image



Seleccionando la Alerta a Enviar


Por último, vamos a seleccionar vía configuración cual es la alerta que queremos enviar desde la clase SearchManager; esto desde nuestro problema de versionamiento sería como instanciar la clase del cliente que corresponde simplemente configurandola desde el archivo de configuración.





<component
id="SearchManager"
type="PruebaCastleWindsor.SearchManager, PruebaCastleWindsor" >
<
parameters>
<
Alert>${Sms.Alert}</Alert>
</
parameters>

</
component>



En esta ocasión, estamos creando un elemento parameters que va a contener la colección de parámetros con que queremos instanciar la clase SearchManager. En este caso queremo enviarle el tipo de alerta que queremos trabajar, por lo que creamos una etiqueta con el nombre de la propiedad que va a almacenar nuestra instancia de Alerta, en nuestro caso se llama Alert. Vamos a cambiar un poco la clase, por que aunque podemos utilizar el parámetro del contructor, no es necesario, ya que CastleWindsor busca la propiedad especificada en la etiqueta, y le crea una instancia con el contenido de la misma, la cual en este caso nos dice que quiere una instancia del componente registrado con el id “Sms.Alert”.



namespace PruebaCastleWindsor
{
public class SearchManager
{
public IAlert Alert { get; set; }

public SearchManager( ) { }

public string DoSearch( string criteria )
{
//Notificamos la búsqueda
if (Alert != null)
return Alert.SendAlert( );
return "Error!";
}
}
}


Si ejecutamos el código anterior, vemos que el mensaje lanzado desde Alert.SendAlert no es el de la alerta por mail como ocurria antes por defecto, si no que es el de alerta por SMS, la cual es la que estamos configurando por parámetro. De nuevo, el código de la clase program no se cambia y el resultado de la ejecución es el siguiente:



image



Conclusión


La idea con este patrón es poder crear instancias de clases por medio de configuración y polimorfismo. Como vimos en este post, esto es posible a través del uso de CastleWindsor, el cual nos permite crear instancias de clases configuradas en el archivo App.config. Esto nos permite crear interfaces con el core de funcionalidades a implementar, e implementar clases que lleven funcionalidad específica para el cliente, las cuales se instancia de acuerdo a lo que se necesite por la aplicación y lo que definamos en el archivo config. En el siguiente post vamos a llevar a cabo la misma tarea, pero utilizando Autofac.



Technorati Tags: ,,

6.12.2009

Versionando Aplicaciones en .NET - Introducción – Parte 1

En muchas ocasiones, me encuentro en diferentes empresas con la finalidad de ayudar a desarrollar una nueva aplicación basado en una versión anterior de la misma utilizando arquitecturas, frameworks y componentes que ayuden a mejorar la velocidad de desarrollo, faciliten el mantenimiento de la misma, y permitan adoptar nuevas funcionalidades no disponibles en la versión anterior. En medio de estos procesos, en la mayoría de los casos, y sobre todo en las empresas que venden su software a terceros, me encuentro con un problema que parece ser muy común:

Como manejar el versionamiento de mi aplicación, si tengo varios clientes y cada cliente tiene formas diferentes de llevar a cabo algunos de sus procesos

Esto sin duda alguna es todo un reto, ya que implica que vamos a tener una sola versión de la aplicación con comportamientos diferentes.

En el pasado – y aún ahora – muchas empresas lo que hacen es crear una copia del proyecto para cada cliente, lo que conlleva a que no se puedan lanzar nuevas versiones del producto, o al menos del corazón de la funcionalidad del producto, por que la empresa terminará teniendo una versión para cada cliente, por lo tanto terminará teniendo tantos productos como clientes tiene. En otras ocasiones, sobre la misma aplicación se empieza a agregar la funcionalidad variante, dividida por estructuras if – else o por algún otro mecanismo que permita esta separación del código; esto por supuesto termina complicando los escenarios de desarrolla en una forma desproporcionada, porque algo que resulta ser un pequeño cambio para un cliente quiebra un montón de funcionalidad en otro cliente.

La pregunta obvia que surge es entonces: ¿Cómo puedo hacer que mis sistemas se desarrollen con el versionamiento para las mismas de una forma más manejable y más simple? La respuesta también es simple: IoC - inversion of control container. Un IoC es un patrón que en conjunto con el Dependency Injection ayuda a ensamblar componentes desde diferentes proyectos en  una aplicación funcional. El patrón en sí se enfoca en como crear instancias de las clases y componentes que necesitamos en tiempo de ejecución sin tener que recompilar y reinstalar la aplicación de nuevo para instanciar otra clase diferente a la definida en la compilación inicial. Información más detallada de el patrón en sí se puede encontrar en la página de Martin Flower.

Existen muchos IoC disponibles en el mercado para su uso libre en la plataforma .NET, y en esta serie de post voy a dedicarme a mostrar como funcionan algunos de estos componentes – los que a mi gusto son los más conocidos. Los IoC que estaré analizando son CastleWindsor, Autofac y Unity Application Block.

En el siguiente post estaré analizando CastleWindsor.

Technorati Tags: ,

6.02.2009

Seleccionando un Ítem en el DataGrid del WPF Toolkit

En un post anterior, mostramos como ligar el DataGrid del WPF toolkit a una colección de entidades generadas en el entity framework vía una capa de lógica de negocios. En este post vamos a obtener la fila seleccionada en el grid por parte del usuario y lo vamos a desplegar en una ventana en modo diálogo.

En este caso, vamos a presentar el usuario seleccionado con doble clic del mouse sobre el registro deseado en el DataGrid del toolkit de WPF. Pero antes de llevar a cabo esta tarea, tenemos que preparar la pantalla en la cual vamos a presentar los detalles del usuario. Para este ejemplo, vamos a utilizar la pantalla DetalleUsuario.xaml utilizada también en un post anterior para agregar usuarios a la base de datos. 

Lo primero que vamos a hacer es crear un constructor en la pantalla que me permita recibir el usuario como parámetro para poder desplegarlo. Una vez recibida la entidad usuario, procedemos a asignarlo a cada uno de los componentes que representan los atributos de la entidad en la pantalla – existen varias formas de hacer databinding en WPF, en este caso vamos a usar la que a mi criterio es la más simple de entender, en post posteriores vamos a ver las diferentes formas de hacer databinding en WPF. El código para llevar a cabo esta tarea es el siguiente:

public DetalleUsuario( )
{
InitializeComponent( );
}

public DetalleUsuario( Usuario usuario )
{
InitializeComponent( );
txtNombre.Text = usuario.Nombre;
txtApellido1.Text = usuario.Apellido1;
txtApellido2.Text = usuario.Apellido2;
txtEmail.Text = usuario.Email;

}



Seguidamente vamos a crear un manejador para el evento doble clic del DataGrid de usuarios en la pantalla AdministracionDeUsuarios.xaml. Para llevar a cabo esta tarea, marcamos el grid, vamos a las propiedades del mismo, y seleccionamos el botón con un ícono de rayo en el tool bar de las propiedades, esto presentará los eventos disponibles del control. Por último buscamos el evento MouseDoubleClick y le damos doble click para que genere el manjeador del evento automáticamente.



image



Una vez generado el handler del evento procedemos a codificar la selección del ítem y la invocación de la pantalla que presenta el detalle del ítem seleccionado.



private void dgUSuarios_MouseDoubleClick( object sender, System.Windows.Input.MouseButtonEventArgs e )
{
Usuario usuarioSeleccionado = dgUSuarios.SelectedItem as Usuario;
DetalleUsuario detalle = new DetalleUsuario(usuarioSeleccionado);
detalle.ShowDialog( );
}


Como podemos ver en el código anterior, la propiedad del grid que nos devuelve el row seleccionado es SelectedItem. En esta misma línea convertimos la fila seleccionada al tipo del objeto que queremos obtener, esto con el operador as.  Este operador tiene la ventaja de que trata de convertir la fila al objeto seleccionado, y si no puede llevar a cabo la conversión, establece la variable usuarioSeleccionado con un valor de null. En este caso la conversión se va a dar, dado que el datagrid esta ligado a una colección – lista – de entidades de usuario. Por último creamos la instancia de la forma donde vamos a presentar el detalle, pero utilizamos el constructor que acabamos de crear, pasándole el usuario obtenido de la selección del Datagrid. Para finalizar, presentamos la pantalla con el detalle.



image