Alternativas para Iniciar con una Arquitectura Orientada a Servicios - SOA

Cuando en una empresa se habla de establecer una arquitectura orientada a servicios surgen muchas dudas respecto a como implementar este tipo de arquitectura. Una de las primeras preguntas que me hacen dentro de la organización cuando llego a ayudar en este tipo de tareas es:

Pero si al prinicipio vamos a tener unos cuantos servicios, por que tenemos que comprar un ESB, que por lo general cuesta mucho dinero.

Efectivamente, una de las principales limitantes a la hora de implementar una arquitectura orientada a servicios – aparte de las limitaciones técnicas – es la compra del software requerido para poder iniciar en SOA.

Normalmente, las empresas empiezan teniendo unos pocos servicios Web, los cuales brindan información ya sea a lo interno o a lo externo; estos servicios se hostean en el IIS. Aunque suene tentador, el hecho de tener solamente servicios web que son consumidos por clientes internos y externos, no implica que tengamos una arquitectura SOA; en realidad estamos creando una arquitectura punto a punto, en donde los clientes consumen directamente los servicios expuestos y quedan totalmente dependientes de la configuración de estos servicios; ya que por ejemplo, si cambian el servidor donde se hostean estos servicios, los clientes tienen que ser actualizados o no funcionarán del todo.

Ahora, conforme crecen la cantidad de servicios que estamos utilizando, empieza a crearse la necesidad de darles seguimiento, de tener un inventario para saber cuales servicios tengo disponibles y puedo reutilizar, de tener métricas de los servicios para poder medir mis SLAs con otros clientes, y muchas otras características típicas de una arquitectura SOA las cuáles nos indican que es hora de ir pensando en un ESB – ver el post de ESB para entender más a fondo que es un ESB – La pregunta que surge es ¿ Cuando debo migrar a un ESB ? ¿por que tengo que pasar de un modelo donde solo tengo que preocuparme por el IIS a un modelo donde tengo que tener otro servidor y debo comprar Biztalk Server y agregarle el ESB guidance? ¿ Por qué no existe un paso intermedio entre ambos, que me de el Governance necesario para poder iniciar con mi arquitectura SOA para poder demostrarle a la gerencia los beneficios de esta arquitectura?

Estas preguntas son totalmente válidas y aplican practicamente en cualquier tecnología sobre la cual estemos interesados en “montar” una arquitectura orientada a servicios. En general cuando me hacen este tipo de preguntas, me pregunto por que no existe un contenedor liviano para ese tipo de soluciones.

Pues resulta que ahora, el equipo de Microsoft Services SOA Solution Team ha creado un producto que viene a llenar ese vacío. Este producto es algo así como el paso intermedio entre la arquitectura punto a punto y la arquitectura SOA en toda su expresión, utilizando un ESB, orquestando servicios y todos los demás beneficios que vienen con una arquitectura orientada a servicios – bien aplicada. Esta herramienta esta en versión CTP y se llama el Microsoft Service Engine – MSE. Esta herramienta es una herramienta para facilitar la adopción de SOA en la empresa, todo a través de algo que se conoce como virutalización de servicios. El MSE esta construida sobre WCF y la plataforma de Windows Server. Se integra de forma natural con Biztalk y el ESB Guidance para cuando en etapas posteriores se desea aumentar la capacidad de governance, ruteo, transformación, etc.

El siguiente screen shot es una muestra de este tool.

Este tool tiene otras 2 ventajas externas a lo técnico: Es Open source y es gratis. El sitio web donde se puede obtener información al respecto esta aquí en codeplex.

En post posteriores voy a profundizar acerca de las funcionalidades de esta herramienta, como configurarlo y como ponerlo a funcionar para poder adoptar una arquitectura SOA dentro de nuestras organizaciones.

Technorati Tags: MSE,SOA,ESB,C#

Personalizando el DataGrid del WPF ToolKit

En el post pasado, creamos una interface gráfica para exponer todos los usuarios que están registrados en nuestro sistema de ejemplo. Esta pantalla estaba compuesta por un grid que mostraba esta información. El grid utilizado, es el grid del WPF Toolkit, el cuál contiene un conjunto de controles sumamente útiles que podemos utilizar de forma gratuita en nuestras aplicaciones desarrolladas con WPF.

En este post vamos a modificar esta pantalla para que el datagrid solo nos muestre los datos relevantes y no todo lo que nos devuelve el objeto desde la entidad proveniente desde el EF. Además vamos cambiar la forma en que luce el grid modificando sus propiedades visuales desde el código XAML.

La ventana en el post anterior lucía de la siguiente manera:

El primer cambio que le vamos a hacer al datagrid es mostrar solamente las columnas que le interesan al usuario de la aplicación, por lo tanto en este caso vamos a eliminar las columnas relacionadas con EF, tales como las relaciones y el EntityState, además vamos a eliminar la columna de borrado lógico Activo. Para lograr esto primeramente debemos poner la propiedad AutoGenerateColumns en falso.

<my:DataGrid Margin="12,51,21,27" Name="dgUSuarios" AutoGenerateColumns="False">

Seguidamente tenemos que definir las columnas que deseamos ligar al grid desde el resultado del método de consulta creado en la lógica de negocios. Esto se logra indicandole a la propiedad Binding a cual propiedad de la entidad devuelta debe de ligarse, tal y como lo muestra el siguiente código:

<my:DataGrid.Columns>
                <my:DataGridTextColumn Header="Id"  Binding="{Binding Id}" IsReadOnly="True" />
                <my:DataGridTextColumn Header="Nombre"  Binding="{Binding Nombre}" IsReadOnly="True" />
                <my:DataGridTextColumn Header="Primer Apellido"  Binding="{Binding Apellido1}" IsReadOnly="True" />
                <my:DataGridTextColumn Header="Segundo Apellido"  Binding="{Binding Apellido2}" IsReadOnly="True" />
                <my:DataGridTextColumn Header="Correo Electrónico" Binding="{Binding Email}" IsReadOnly="True" />
            </my:DataGrid.Columns>

Ahora vamos a pintar cada una de las filas con un color alternativo, en este caso, una fila de un color verde en gradiente y la siguiente de un color verde sin gradiente. El código XAML para lograr esto es el siguiente:

<my:DataGrid Margin="12,51,21,27" Name="dgUSuarios" AutoGenerateColumns="False" 
                     RowBackground="#FF70947A" AlternatingRowBackground="{StaticResource GradienteVerde}">

El gradiente verdes esta en los recursos del grid, es decir en el <Grid.Resources> y su contenido es el siguiente:

<LinearGradientBrush x:Key="GradienteVerde" EndPoint="1,0.5" StartPoint="0,0.5">
    <GradientStop Color="#FF227D2C" Offset="0"/>
    <GradientStop Color="#FF046B0E" Offset="1"/>
</LinearGradientBrush>

La pantalla debe de lucir de la siguiente manera:

Por último vamos a cambiarle el estilo al header del grid. El primer paso para lograr esto, es crear un estilo para poder asignarselo al grid. El estilo a utilizar lo vamos a definir en el archivo app.xml en la seccion de recursos de la aplicación.

<Application.Resources>
    <LinearGradientBrush x:Key="GridBackGround" EndPoint="1,0.5" StartPoint="0,0.5">
        <GradientStop Color="#FF000000" Offset="0"/>
        <GradientStop Color="#FF121111" Offset="1"/>
        <GradientStop Color="#FF605D5D" Offset="0.50"/>
    </LinearGradientBrush>
    <Style x:Key="HeaderStyle" TargetType="{x:Type Primitives:DataGridColumnHeader}">
        <Setter Property="VerticalContentAlignment" Value="Center" />
        <Setter Property="Background" Value="{StaticResource GridBackGround }" />
        <Setter Property="Foreground" Value="Orange" />
    </Style>
</Application.Resources>

Como podemos ver en el estilo, las propiedades de background y foreground han sido cambiadas para que el header el background del header se vea de acuerdo al gradiente GridBackGround y el foreground se establece de color naranja.

Seguidamente lo agregamos el estilo al grid.

ColumnHeaderStyle="{StaticResource HeaderStyle}" 

Para lograr esto, establecemos la propiedad ColumnHeaderStyle con el valor del estilo que definimos en el bloque de código anterior.

La pantalla de resultado es la siguiente:

Technorati Tags: WPF,WPF Toolkit DataGrid,XAML

El Entity Framework en una Arquitectura n-layer – Parte 4

En el post anterior iniciamos el desarrollo de la capa de UI utilizando WPF como tecnología. En este post vamos a continuar agregando funcionalidad al UI del sistema que estamos desarrollando.

En esta oportunidad, vamos a agregar una pantalla para ver todos los usuarios que hemos insertado dentro de la aplicación.

Creando la Pantalla de Administración de Usuarios

El primer paso es crear una nueva pantalla en el proyecto y llamarla AdministracionDeUsuarios. Esta pantalla va a tener un grid el cual nos va a presentar todos los usuarios que existen en nuestra aplicación. El grid que vamos a utilizar es el DataGrid del toolkit de WPF. A este datagrid le vamos a llamar dgUsuarios. Una vez creada la pantalla esta lucirá de la siguiente forma:

El siguiente paso es llenar el datagrid con los datos de usuarios que tenemos incluidos en nuestra base de datos. Para lograr esto vamos a utilizar el método ObtenerUsuarios de nuestra clase de lógica de negocios para el usuario. El código para llevar a cabo esta tarea es el que se presenta a continuación:

using System.Windows;
using LogicaDeNegocios;

namespace Cliente_WPF
{
    public partial class AdministracionDeUsuarios : Window
    {
        public AdministracionDeUsuarios( )
        {
            InitializeComponent( );
        }

        private void Window_Loaded( object sender, RoutedEventArgs e )
        {
            UsuarioBL usuarioBL = new UsuarioBL( );
            dgUSuarios.ItemsSource = usuarioBL.ObtenerUsuarios( );
        }
    }
}

Como se puede ver en el código anterior, solamente necesitamos crear una instancia de la clase UsuarioBL y ligar el datagrid con los datos que nos retorna el método ObtenerUsuarios el cual definimos en el post 2 de esta serie. Si ejecutamos la aplicación poniendo como forma de arranque la forma recién creada el resultado será el siguiente:

Como podemos ver en la imagen anterior, no solo se presentan los datos propios de la entidad en el grid, si no las relaciones existentes entre el usuario y el historial de casos de uso, el estado de la entidad que es utilizado para persistir cambios en el back end, y la llave de la entidad.

En el próximo post vamos a trabajar mejorando la presentación de este datagrid.

Technorati Tags: C#,Entity Framework,n-layer,WPF

El Entity Framework en una Arquitectura n-layer – Parte 3

En los posts anteriores creamos la capa para la lógica de negocios y la capa de acceso a datos utilizando el entity framework. En este post, vamos a crear la capa de presentación de la aplicación de ejemplo utilizando WPF.

El primer paso es crear un nuevo proyecto dentro de la solución en la cual hemos venido trabajando. El proyecto a crear es una aplicación WPF.

Seguidamente, eliminamos la forma que se crea por defecto, y creamos una nueva pantalla. En este caso, vamos a crear una pantalla para agregar un usuario. Como podemos ver en el primer post, un usuario tiene básicamente los siguiente campos:

• Id
• Nombre
• Apellido1
• Apellido2
• Email
• Activo.

De estos campos, el Id es autogenerado y el campo de activo es para borrado lógico por lo que en la inserción por defecto, el campo se guarda con un valor de “Y”.

La pantalla que vamos a crear por lo tanto deberá lucir como se ve en la siguiente figura:

Seguidamente vamos a agregar el código necesario para agregar la entidad ingresada en la forma, pero antes de esto, debemos agregar una referencia a la capa de lógica de negocios y a la capa de acceso a datos. A esta última la tenemos que agregar por que las entidades son el “medio de transporte” entre las capas, y como no tenemos una capa de entidades separada, entonces tenemos que agregarla desde la capa de acceso a datos. Además se debe de agregar una referencia a la librería System.Data.Entity. El código lucirá de la siguiente forma:

using System.Windows;
using CapaDeAccesoADatos;
using LogicaDeNegocios;

namespace Cliente_WPF
{
    public partial class DetalleUsuario
    {
        public DetalleUsuario( )
        {
            InitializeComponent( );
        }
        private void btnOk_Click( object sender, RoutedEventArgs e )
        {
            Usuario usuario = new Usuario( );
            usuario.Nombre = txtNombre.Text;
            usuario.Apellido1 = txtApellido1.Text;
            usuario.Apellido2 = txtApellido2.Text;
            usuario.Email = txtEmail.Text;
            usuario.Activo = "Y";
            UsuarioBL usuarioBL = new UsuarioBL( );
            usuarioBL.AgregarUsuario(usuario);
        }
    }
}

Como podemos ver, lo único que hacemos es crear una entidad, crear una instancia de la clase usuario de la lógica de negocios e invocar el método agregar usuario pasando de parámetro la entidad del usuario recién creada. Este código, además de simple, es sencillo de mantener y permite que todos los desarrolladores que estén trabajando en el proyecto, tengan un estilo similar para programar, lo que facilita el hecho de que una persona no este disponible para modificar o agregar funcionalidad a una pantalla.

Si ejecutamos la pantalla anterior, veremos la siguiente pantalla en ejecución:

Si ingresamos datos, y le damos ok, vamos a recibir el siguiente error de parte del entity framework:

The specified named connection is either not found in the configuration, not intended to be used with the EntityClient provider, or not valid.

Esto quiere decir que el entity framework no esta encontrando el conection string para pegarse a la base de datos. Este connection string se encuentra en el archivo app.config de la librería de acceso a datos; pero en este caso, como no tenemos configurada la salida de todos los proyectos al mismo directorio – algo de lo que vamos a ir conversando en post posteriores – entonces la aplicación no lo logra localizar. Para solucionar este problema de forma rápida – y temporal -  debemos simplemente agregar un archivo app.config al proyecto del cliente WPF y copiar el connection string desde el app.config de la capa de acceso a datos.

El primer paso es agregar el archivo config al cliente de WPF.

Seguidamente copiamos desde el archivo app.config de la capa de acceso a datos, el string de conexión al archivo recién creado

<connectionStrings>
    <add name="UseCasesEntities" connectionString="metadata=res://*/UseCasesModel.csdl|res://*/UseCasesModel.ssdl|res://*/UseCasesModel.msl;provider=System.Data.SqlClient;provider connection string=&quot;Data Source=diego-pc\sqlserver2008;Initial Catalog=UseCases;Integrated Security=True;MultipleActiveResultSets=True&quot;" providerName="System.Data.EntityClient" />
  </connectionStrings>

Seguidamente, procedemos a ejecutar la aplicación y a insertar los usuarios que vayamos a necesitar.

En el siguiente post, vamos a crear una pantalla para que se nos muestre a través de el DataGrid del toolkit de WPF, todos los usuarios ingresado en la base de datos.

Technorati Tags: WPF,Entity Framework,C#,n-layer

El Entity Framework en una Arquitectura n-layer – Parte 2

En el post anterior, iniciamos el desarrollo de una aplicacion n-layer utilizando en Entity Framework. En el post mencionado definimos y construimos la capa de acceso a datos la cual esta compuesta principalmente por el Entity Framework – aunque como veremos en futuros post, esta capa se va a extender con clases que le agrega funcionalidad el Entity Framework. En este post vamos a construir la capa de lógica de negocios para la aplicación que estamos desarrollando.

La capa de negocios es la capa en la cual vamos a crear los métodos unitarios que llevan a cabo las tareas correspondiente de cada una de las entidades. Estas tareas incluyen desde las operaciones CRUD – create, retrieve, update, delete – hasta procesos de negocios más elaborados.

Para crear esta capa de negocios, vamos a crear una librería utilizando los mismos pasos que hicimos en el post anterior, pero vamos a llamar la libreria como LogicaDeNegocios.

Al igual que hicimos en la librería de la capa de acceso a datos, vamos a eliminar la clase que es creada por defecto cuando creamos el componente. La solución ahora debería lucir así:

Seguidamente vamos a crear las clases de lógica de negocios para poder llevar a cabo operaciones que se requieran para cada entidad. En este caso, vamos a crear la clase de lógica de negocios para la entidad Usuario. Para crear esta clase, le damos click derecho sobre el proyecto de lógica de negocios y seleccionamos agregar nuevo ítem –> Agregar Clase. En el diálogo de agregar clase escribimos UsuarioBL como nombre de la clase, para poder identificar la clase de lógica de negocio para el usuario en las capas de presentación que vayamos a crear o incluso en la capa de servicios si deseamos crear una para permitir que nuestra funcionalidad de negocios se pueda acceder a través de servicios.

El siguiente paso es agregar una referencia a la capa de acceso a datos para así poder tener visibilidad de las operaciones existentes dentro del modelo de entidades creado en esa librería. Para lograr esto, le damos click derecho al proyecto de lógica de negocios y seleccionamos la opción agregar referencia del menu contextual. En el dialogo de agregar referencias seleccionamos la cejilla de proyectos y escojemos el proyecto para capa de acceso a datos.

La referencia debe poder verse en la carpeta de referencias del proyecto como se muestra a continuación.

Una vez agregada la referencia, procedemos a agregar el uso de la librería en la clase recién creada. Esto se logra a través de la instrucción using, seguidamente creamos una propiedad automática para tener acceso al modelo de entitdades que creamos anteriormente en la capa de acceso a datos.

Como se puede ver en la figura anterior, es requerido agregar la librería System.Data.Entities para poder hacer uso de las entidades presentes en la capa de acceso a datos. En post posteriores vamos a analizar con un poco más de profundidad el entity framework y estos detalles. Para agregar esta librería seguimos el mismo proceso que llevamos a cabo anteriormente para agregar la referencia a la capa de acceso a datos, solo que esta vez vamos a buscar la librería en la cejilla de .NET.

Una vez agregada esta referencia, la clase actual para manejar la lógica de de negocios del usuario ya compila.

Un aspecto a destacar, es que agregamos una propiedad dinámica para tener acceso al modelo de entidades que acabamos de agregar desde la capa de acceso a datos, y además instanciamos el modelo de entidades generado desde el constructor de la clase. Este comportamiento puede no ser el deseado ya que puede producirnos trabajo extra a la hora de agregar relaciones que se obtienen desde otras clases de lógica de negocios por que cada clase va a venir de diferentes instancias del modelo, es decir desde diferentes contextos. En el post de como extender y mejorar el EF en una arquitectura n-layer vamos a ver cuales pueden ser las posibles soluciones para manejar estos casos.

Seguidamente procedemos a crear los métodos principales de CRUD en la lógica de negocios. Primeramente vamos a crear el método para agregar un usuario.Este método recibe una entidad del tipo Usuario, y la agrega al contexto instanciado utilizando el método generado AddToUsuario. Finalmente, procedemos a persistir los cambios en la base de datos utilizando el metodo SaveChanges.

En muchas ocasiones surge la pregunta, ¿por qué recibir un usuario y no los campos para agregar a la entidad? La respuesta esta relacionada con la adaptabilidad al cambio de parte de la aplicación. Puede ser que en un futuro se requiera quitar o agregar campos a la entidad usuario; si estamos utilizando lo campos en lugar de una entidad, vamos a tener que modificar todos los métodos donde interactuamos con la entidad para modificar, actualizar, seleccionar, etc. Sin embargo, si utilizamos una entidad, los puntos que varían son la entidad, el UI en donde construimos la entidad y la capa de acceso a datos donde agregamos los campos al repositorios – si estamos usando el EF, no se requieren cambios en la capa de acceso a datos ya que el EF actualiza los métodos desde el modelo – con lo que nuestra aplicación es más fácil para modificar.

Seguidamente procedemos a crear los métodos necesarios para obtener todos los usuarios que existen en la base de datos, y el método que me retorna un usuario en específico.

Inicialmente agregamos la referencia a la librería System.Linq, esto para tener acceso a los métodos de extensión

using System.Collections.Generic;
using CapaDeAccesoADatos;
using System.Linq;

Seguidamente creamos los métodos mencionados anteriormente. En este caso vamos a utilizar la sintaxis del EF para acceder a los datos. En post posteriores vamos a utilizar LinqToEntities para llevar a cabo las mismas tareas.

public List<Usuario> ObtenerUsuarios( )
{
    var usuarios = ModeloEntidades.Usuario;
    return usuarios.ToList( );
}

public Usuario ObtenerUsuario( int id )
{
    var usuario = ModeloEntidades.Usuario.Where(u => u.Id == id).FirstOrDefault( );
    return usuario;
}

Con estos métodos ya tenemos un conjunto de funcionalidad suficiente para poder trabajar con nuestra capa de UI. Digo suficiente por que por supuesto faltan los métodos para actualizar y borrar usuarios, además los correspondientes métodos para asociar los usuarios a las entidades correspondientes. Estos métodos los vamos a agregar en futuros post.

La solución de la aplicación debe de lucir de la siguiente manera:

En el próximo post vamos a crear la capa de UI utilizando WPF.

Technorati Tags: Entity Framework,C#,n-layer

El Entity Framework en una Arquitectura n-Layer – Parte 1

En el post anterior acerca del Entity Framework en una arquitectura n-layer, describí el rol que juega el EF en una arquitectura n-layer. En este post vamos a crear un ejemplo para mostrar como se plasma en código las ideas expuestas en el post anterior.

En este caso, vamos a trabajar en el desarrollo de una “mini” aplicación que administra los casos de uso de n empresas – al menos desarrollar un poquito de funcionalidad de la aplicación para ilustrar los conceptos expuestos.

La Base de Datos

El primer paso es crear una base de datos para persistir la información de los proyectos. Vamos a crear una base de datos utilizando SQLServer2008. Esta base de datos se llamará UseCases. El diagrama inicial de la base de datos es el siguiente.

En este caso, vamos a decir que una empresa puede tener varios proyectos, y que cada proyecto tiene muchos casos de uso. Cada caso de uso tiene un historial de acciones que se graba cada vez que se realiza un cambio en el caso de uso ( esto suponiendo una base de datos completa, en donde se guardan los diferentes flujos del caso de uso, sus actores, etc). Por último, cada registro del historial de cambios tiene un usuario asociado que es precisamente el que realizó el cambio.

Desarrollando la Solución

Para el desarrollo de la solución vamos a utilizar Visual Studio 2008 SP1. El primer paso es crear una solución vacía para ir agregando los diversos proyectos que vamos a ir requiriendo en el desarollo de la aplicación. Para crear una solución vacía seleccionamos: new project –> visual studio solutions –> Blank Solution.

Creando la capa de Acceso a Datos

Una vez que tenemos la solución, vamos a crear la capa de acceso a datos ( que por lo general es el primer bloque que se crea cuando se realiza un proyecto con arquitectura n-layer). Para agregar el proyecto, seleccionamos con el botón derecho del mouse la solución recién creada y seleccionamos del menú contextual agregar nuevo proyecto.

Cuando aparece la opción de seleccionar el tipo de proyecto deseado seleccionamos la opción de class library en el tipo de proyecto Windows bajo C#. Al proyecto le vamos a poner de nombre CapaDeAccesoADatos.

Después de creada la capa de acceso a datos – al menos el proyecto – procedemos a agregar el modelo del entitiy framework. Debemos recordar, que en el post anterior mencioado al principio de este post, indicabamos que el EF sustituye a la capa de acceso a datos. Por esta razón en este componente de acceso a datos, solamente vamos a tener el modelo generado por el EF; en post posteriores vamos a extender el EF con clases adicionales que se agregarán a esta librería.

Para crear un modelo de entitidades le damos clic y botón derecho al proyecto recién creado y seleccionamos agregar nuevo ítem.

En el diálogo de seleccionar ítem escojemos la opción ADO.NET Entity Model. Le vamos a llamar UseCasesModel.

Cuando inicia el “wizard” del EF en el primer paso seleccionamos la opción generar desde base de datos. Seguidamente creamos una nueva conexión a la base de datos que recién acabamos de crear; le decimos además al wizard que agregue el string de conexión al archivo app.config con el nombre UseCasesEntities.

Seleccionamos Next y procedemos a seleccionar las tablas que vamos a utilizar en nuestro modelo. En este caso, vamos a mapear en el modelo, todas las tablas creadas en el diseño de la base de datos hecha en SQLServer.

El modelo generado es el siguiente

Podríamos caer en la tentanción de pensar que lo único que el EF hace es mapear las tablas en clases y ponerlas a nuestra disposición para las tareas tradicionales que llevamos normalmente a cabo en una base de datos tales como el CRUD. Pero si vemos el modelo generado con atención, podemos ver que han sucedido cosas interesantes gracias a la forma en que ser tratan las relaciones entre objetos y entre tablas. Tal vez el cambio que esta más a la vista, es que los campos que manejan las llaves foráneas en la base de datos, fueron sustituidas por objetos de navegación. Esto nos permite una mayor flexibilidad ya que podemos navegar en ambas direcciones en la tabla, y el EF se encarga de administrar las relaciones a nivel de tablas.

En el paso que estamos, la solución debería lucir de la siguiente manera:

En este momento solo tenemos una librería – dll – que va a convertirse en mi capa de acceso a datos. En el próximo post, vamos a desarrollar la capa de lógica de negocios.

Technorati Tags: Entity Framework,C#

¿Qué es un ESB – Enterprise Service Bus?

Cuando se habla de arquitecturas orientadas a servicios, se habla intrínsicamente de los componentes necesarios para tener una arquitectura SOA. Sin duda alguna, uno de los componentes más importantes de una arquitectura orientada a servicios es el Enterprise Service Bus - ESB.

Conforme las organizaciones van moviéndose hacia las arquitecturas orientadas a servicios, se dan cuenta que están trabajando con un “mix” entre lo nuevo y lo viejo. Un ESB es básicamente la integración de lo nuevo y lo viejo, brindándo un lugar central para los servicios, las aplicaciones, y recursos de TI en general que se desean conectar. En otras palabras, lo que se busca es una infraestructura y un sistema de eventos que me permitan conectar cualquier recurso de TI sin importar la tecnología que utiliza el recurso. Esta infraestructura debería permitir administrar los cambios en los requerimientos sin causar problemas a los servicios ya instalados. Esta infraestructura debe de ser confiable y robusta. Aquí es donde entra el concepto de ESB.

Un ESB no solamente permite combinar y re ensamblar servicios, sino que también debe permitir conectar nuevas aplicaciones, servicios web y cualquier otro tipo de aplicaciones tales como aplicaciones LOB ( Line of Business ), archivos batch, legacy middleware a través de adaptadores; todo esto manteniendo la abstracción del manejo de mensajes a través del patrón publicar-suscribir.

Siendo más concretos, podemos decir que un ESB ofrece las siguientes funcionalidades:

• Transparencia de Ubicación: El ESB ayuda a desligar el consumidor del servicio de la ubicación del proveedor del servicio. El ESB provee una plataforma central para comunicarse con cualquier aplicación requerida sin ligar el recibidor del mensaje con el que envía el mensaje.
• Conversión de Protocolo de Transporte: Un ESB debe de tener la capacidad de integrar de forma transparente a través de diferentes protocolos de transporte tales como HTTP(s), JMS, FTP, SMTP, TCP, etc.
• Transformación de Mensaje: El ESB brinda funcionalidad para transformar mensajes desde un formato hasta otro formato basado en estándares tales como XSLT y XPath.
• Ruteo de Mensajes: El ESB determina el destino de los mensajes entrantes.
• Mejora del Mensaje: El ESB puede brindar funcionalidad para agregar información faltante basado en los datos del mensaje de entrada.
• Seguridad: Autenticación, autorización, y funcionalidad de encriptación se proveen a través del ESB para asegurar los mensajes entrantes. Igualmente estas funcionalidades se aplican a mensajes salientes para satisfacer requerimientos de seguridad del proveedor del servicio a consumir.
• Monitoreo y Administración: Un ambiente de monitoreo y administración del ESB es fundamental para configurar el ESB para que sea confiable y tenga un alto desempeño; al mismo tiempo, nos permite monitorear la ejecución de los mensajes y su flujo dentro del ESB.

La siguiente figura nos muestra un “big picture” de lo que es un ESB.

Dadas estas funcionalidades de un ESB, ¿cuándo necesito utilizar un ESB?

Conforme las organizaciones van adoptando servicios, se va creando la necesidad de una arquitectura orientada a servicios. Hay una gran diferencia entre el uso casual de servicios y llevar la organización a correr sobre servicios. Conforme se avanza hacia una arquitectura orientada a servicios, van a surgir muchos contratiempos, entre los cuales podemos enumerar como manejar una gran cantidad de servicios de una manera adecuada evitando la duplicación de funcionalidad, como medir y forzar los SLA´s –Service Level Agreement –, como forzar politicas organizacionales dentro de la colección de servicios que se tiene y a la cual se le van agregando servicios.

Además, en el mundo Microsoft existe WCF, el cual es un framework excelente para comunicaciones distribuidas, pero es solo eso, un framework.

Normalmente, cuando se empiezan a tener una cantidad de servicios que deja de ser pequeña y más bien podríamos considerarla de mediana a grande, se empiezan a tener problemas que no se tenían cuando solamente se manejaban un grupo pequeño de servicios. Entre los problemas que se dan más comúnmente podemos enumerar proliferación de servicios por toda la organización sin control, los cuales utilizan diferentes protocolos y tecnologías para su desarrollo e implementación. No hay governance, las configuraciones no son estándar, no hay versionamiento de servicios, etc. Cuando se empiezan a tener este tipo de problemas, y la organización empieza a dar un paso más serio hacia el uso de servicios como plataforma para sus aplicaciones, se empieza a necesitar más y más una arquitectura orientada a servicios.

Como agregar un binding TCP de forma programada a un sitio web en IIS 7.0

La información del binding en un sitio web es indispensable para indicar cuales protocolos pueden ser utilizados para comunicarse con el sitio Web. En el contexto de WCF esto significa, que tipos de protocolos vamos a poder utilizar para consumir los servicios desarrollados en WCF y hosteados en IIS 7.0 y WAS.

En días pasados conversando con algunas personas que usan IIS 7.0 para hostear servicios en WAS utilizando el protocolo TCP, me preguntaron como agregar el binding de TCP a un sitio web utilizando el API de IIS 7.0 y C#. La consulta me pareció muy útil por que permite crear instaladores que hagan deploy de los servicios de forma transparente, incluso creando sus sitios webs a la hora de la instalación y agregando el binding deseado con este instalador. Aquí esta la solución a esta consulta.

Primeramente, vamos ver que es lo que necesitamos para tener el protocolo TCP habilitado en el sitio web. Para esto, en el archvio applicationHost.config  existe la sección bindings la cual existe por sitio web definido y tiene el siguiente formato:

<bindings>
    <binding protocol="http" bindingInformation="*:80:" />
    <binding protocol="net.tcp" bindingInformation="808:*" />
    <binding protocol="net.pipe" bindingInformation="*" />
    <binding protocol="net.msmq" bindingInformation="localhost" />
    <binding protocol="msmq.formatname" bindingInformation="localhost" />
</bindings>

Como podemos ver en el elemento XML anterior, existe una etiqueta binding para cada protocolo que queremos soportar en el sitio web. Además, cada elemento tiene dos atributos: protocol y bindginInformation. El protocolo define el protocolo que se utiliza para comunicarse con el sitio web, y el bindingInformation contiene la dirección IP, el número del puerto y opcionalmente el host header para el sitio web.

Para poder agregar TCP al sitio web deseado debemos primeramente buscar el elemento que contiene los sitios web en el archivo de configuración del servidor, seguidamente buscamos el sitio web deseado, y procedemos a agregarle el binding. El código para esta operación es el siguiente:

public static void AgregarBindiingASitioWeb( string nombreSitioWeb, string protocolo, string bindingInformation )
       {
           using (ServerManager server = new ServerManager( ))
           {
               Configuration hostConfiguration = server.GetApplicationHostConfiguration( );
               ConfigurationSection sitesSection = hostConfiguration.GetSection("system.applicationHost/sites");  //utilizamos XPath para obtener el elemento
               ConfigurationElementCollection sitesCollection = sitesSection.GetCollection( );  //Obtenemos todos los sitios web en el archivo
               //Buscamos el sitio web deseado
               ConfigurationElement siteElement = FindElement(sitesCollection, "site", "name", @nombreSitioWeb);
               //Si no existe, lanzamos una excepción y abortamos el método.
               if (siteElement == null) throw new InvalidOperationException("Sitio no encontrado!");
               //Obtenemos la configuración del binding del sitio web
               ConfigurationElementCollection bindingsCollection = siteElement.GetCollection("bindings");
               //Creamos un elemento de binding para el sitio y le establecemos los valores deseados
               ConfigurationElement bindingElement = bindingsCollection.CreateElement("binding");
               bindingElement["protocol"] = @protocolo;
               bindingElement["bindingInformation"] = @bindingInformation;
               //Agregamos el binding a la colección de bindings del sitio web
               bindingsCollection.Add(bindingElement);
               //Guardamos los cambios en el archivo applicationHost.config
               server.CommitChanges( );
           }
       }


       private static ConfigurationElement FindElement( ConfigurationElementCollection collection, string elementTagName, params string[] keyValues )
       {
           //Iteramos sobre la coleccion de elementos para buscar la etiqueta site que tenga en el atributo
           //name el valor pasado por parámetro
           foreach (ConfigurationElement element in collection)
           {
               //Si el elemento encontrado es el sitio
               if (String.Equals(element.ElementTagName, elementTagName, StringComparison.OrdinalIgnoreCase))
               {
                   bool matches = true;
                   //Entonces buscamos el atributo deseado
                   for (int i = 0; i < keyValues.Length; i += 2)
                   {
                       object o = element.GetAttributeValue(keyValues[i]);
                       string value = null;
                       if (o != null)
                       {
                           value = o.ToString( );
                       }
                       if (!String.Equals(value, keyValues[i + 1], StringComparison.OrdinalIgnoreCase))
                       {
                           matches = false;
                           break;
                       }
                   }
                   if (matches)      
                   {
                       return element;
                   }
               }
           }
           return null;
       }

El código para llamar al método de crear binding es:

AgregarBindiingASitioWeb("MiNuevositioWeb", "net.tcp", "808:*");

Antes de ejecutar el código anterior, el elemento Site de MiNuevoSitioWeb lucía así:

Después de ejecutar el código anterior el resultado es:

Como podemos ver en la figura anterior, el binding para TCP se agregó al elemento del sitio web solicitado.

Eclipse y Silverlight

Normalmente, cuando pensamos en silverlight pensamos en .NET. Resulta ser, que una empresa francesa en conjunto con Microsoft, desarrolló un plug in para Eclipse que permite desarrollar aplicación silverlight utilizando Java.

El articulo que nos muestra que contiene este plug in se puede ver en el sitio de la empresa que desarrolla el plug in. Los pasos para utilizar este plug in con eclipse se pueden ver en el blog de somasegar en el msdn.

También es interesante destacar un producto llamado eFace de esta empresa, que permite desarrollar UI’s utilizando XAML en Java. El link de este producto – el cual tiene una versión gratuita – se puede ver acá.

Utilizando el API de IIS 7 para crear Web Sites Aplicaciones, Directorios Virtuales y para explorar mi servidor Web desde .NET

En días pasados tuve la necesidad de crear una aplicación que me permitiera llevar a cabo acciones sobre el IIS para poder realizar acciones tales como crear un Sitio Web desde una aplicación desarrollada en C#. Es por eso, que en este post decidí escribir un poco acerca de como llevar a cabo estas tareas utilizando VS 2008, C#, IIS 7.0 y el API manejado para acceder las funcionalidades del IIS – al menos algunas.

El API de IIS 7.0 es una librería localizada en el directorio C:\Windows\System32\inetsrv\ – Asumiendo que la instalación de Windows esta en el disco C – y es un assemblie que se llama Microsoft.Web.Administration.dll. Esta vez, vamos a hacer una aplicación de consola que nos permita realizar un par de tareas contra el IIS.

Una vez creada la aplicación de consola procedemos a agregar una referencia al componente que nos va a exponer la funcionalidad disponible del IIS, es decir, el Microsoft.Web.Administration.dll. La siguiente figura nos muestra la referencia agregada al proyecto de ejemplo.

Una vez agregada esta referencia, procedemos agregar la referencia a la libreria para poder utilizarla en nuestra aplicación tal y como se muestra en el siguiente código:

using System;
using Microsoft.Web.Administration;

Luego a agregar funcionalidad a nuestra aplicacion para acceder al IIS 7.0. Lo primero que vamos a hacer es desplegar la lista de sitios web que han sido creados en el IIS con el que vamos a interactuar, en este caso, el servidor Web local. El código para llevar a cabo este procedimiento es el siguiente.

static void Main( string[] args )
{
    ListarSitiosWeb( );
}

private static void ListarSitiosWeb( )
{
    using (ServerManager server = new ServerManager( ))
    {
        foreach (Site site in server.Sites)
        {
            Console.WriteLine("Sitio Web:{0}", site.Name);
        }
    }
}

Como se ve en el código anterior, lo primero que debemos hacer es crear una instancia de la clase ServerManager, la cual representa el servidor Web instalado en mi máquina. Seguidamente, para imprimir el nombre de los sitios web creados en el servidor Web simplemente recorro la colección de Sites presente en mi servidor web. La salida de este código es:

Para crear un Sitio web desde mi aplicación en .NET utilizo el siguiente código.

/// <summary>
/// Permite crear un web site utilizando el API de IIS 7
/// </summary>
/// <param name="siteName">El nombre del sitio web</param>
public static void CreateSite( string siteName )
{
    try
    {
        using (ServerManager mgr = new ServerManager( ))
        {
            Site newSite = mgr.Sites.CreateElement( );
            newSite.Id = DateTime.Now.Second;
            newSite.SetAttributeValue("name", siteName);
            mgr.Sites.Add(newSite);
            mgr.CommitChanges( );
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error: {0}", ex.ToString( ));
    }
}

Este código permite crear un sitio web con el nombre que viene por parámetro – siteName – y con un Id obtenido del segundo en que fue creado el sitio web. Seguidamente agregamos el sitio a la colección de sitios del IIS, y le damos CommitChanges para refrescar el sitio web.

Otra funcionalidad con la que tenemos que trabajar cuando creamos es crear una Aplicación. Una aplicación en IIS es un agrupamiento de contenido en un sitio Web. Estas aplicaciones tienen una ruta física para el contenido y propiedades que son específicas al contenido indicado. Para crear una aplicación en el sitio web antes creado agregamos el siguiente código.

private static void AgregarAplicacion( string sitioWeb )
{
    try
    {
        using (ServerManager server = new ServerManager( ))
        {
            server.Sites[sitioWeb].Applications.Add("/", @"C:\Proyectos\MiSitio");
            server.CommitChanges( );
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error creando aplicación {0}: {1}", sitioWeb, ex.ToString( ));
    }
}

En este código, el método Add de la colección de aplicaciones del sitio web recibe dos parámetros, el primero es la ruta dentro del servidor web donde se va a administrar el contenido – en este caso en el directorio raíz del sitio web - , y el segundo parámetro que indica la ubicación física del contenido.

Por último, le vamos a agregar un directorio virtual a la aplicación que acabamos de crear.

public static void AgregarDirectorioVirtual( string nombreSitioWeb, string aplicacion )
{
    using (ServerManager server = new ServerManager( ))
    {
        Site sitioWeb = server.Sites[nombreSitioWeb];
        Application app = sitioWeb.Applications[aplicacion];
        app.VirtualDirectories.Add("/ASPX", @"C:\Proyectos\MiSitio");
        server.CommitChanges( );
    }
}

Este código agregar un directorio virtual llamado ASPX, en la ruta física C:\Proyectos\MiSitio, por lo tanto va a estar mapeado a esta dirección física.