Nunca he participado en un concurso como este, pero es un buen chance, no habría porque no intentarlo.

10puntos.info es un blog que desde mi punto de vista es muy original. Su contenido hace referencia a 10 puntos en forma de lista, acerca de diferentes temas que van desde curiosos, hasta interesantes. Desde que lo leí por primera vez, me llamo la atención y lo coloque en mi Blogroll para leerlo más seguido (claro, siempre y cuando el trabajo y el tiempo libre lo permita).

Como una forma de fortalecer la imagen del blog, su dueño a lanzado una convocatoria para participar en un concurso y poder ganar un servicio de hosting (para el primer lugar) y un dominio (para el segundo lugar) como premios importantes, gratis por un año (muy interesante)

Y bueno, aquí me ven participando en él, una vez que nunca de los nunca, ni siquiera en las canicas he ganado algo jojo.

Suerte a todos!

Nota: el concurso termina el 31 de agosto.

Nombre: Ramírez Leyva, José Roberto.
Grado: Maestría.
Programa: MATI - Mtro. en Administración de Tecnologías de Información.

Una vez terminado mi programa academico, solo queda la tesis =)

Your shadow walks faster than you
You don’t really know what to do
Do you think that you’re not alone?
You really think that you’re immune to it
Its going get that the best of you
Its going lift you up and let you down
Hmm hmm humm

It will defeat you then teach you to get back up
After it takes away all that you learn to love

Your reflection is a blur
Out of focus but in confusion
The frames the sun did burn
At the end of a roll of delusions
A ghost waiting its turn
And now I can see right through it
It’s a warning that nobody heard

It will teach you to love what you’re afraid of
After it takes away all that you’ve learn to love

But you don’t, always
Have to hold your head
Higher than your heart

You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better be hoping you’re not so…

Du du rut
Hope you’re not alone
Hmm hmm humm

Your echo comes back out of tune
Now you can’t quite get used to it
Reverb is just a room
The problem is that there’s no truth to it
It’s fading away too soon
Your shadow is on the move
And maybe you should be moving too

Before it takes away all that you learned to love
It will defeat you and then teach you to get back up

‘Cause you don’t, always
Have to hold your head
Higher than your heart

You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better be hoping you’re alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not so…

Du ru ru ru ru
Hope you’re not alone
Hmm hmmm hmmmm
Better hooope
Huuu huuu hmmm
Better hope you’re not alone
Huuu huuu hmmm
hooope

Pareciera que fue ayer el día que un desgraciado de la manera más cobarde, después de casi matarme, después de llevarlo a él y a su acompañante a su casa y de pensar de manera más positiva en que todo se arreglaría, este no se hiciera responsable de sus estupideces. Pues véanme ahora, ya paso más del año y medio y después de una infinidad de vueltas con el ministerio público (MP), estiras y aflojes, depresiones por observar el estado tan deplorable en el que se encuentran nuestras instalaciones de seguridad pública, esto aun no termina.

Hay algo positivo, esta semana me dieron una buena noticia los señores agentes del MP. Espero de una vez poder terminar con esto y ver al fulano tras-las-rejas o bien reponiéndome el daño.

Por otro lado tenemos la información, los datos, y probablemente todos nosotros en nuestros desarrollos hemos trabajado con bases de datos relacionales tales como SQL Server, MySQL, entre otras. Esta información seguramente necesitara cambiar e irse modificando, así como también necesitaremos tener esta información disponible cuando queramos, esto en al área de desarrollo de sistemas se le conoce como persistencia. Como se relaciona esto? el modelo relacional de datos es la representación más clara de los objetos de negocio que existen en nuestro dominio de sistema y este necesitara almacenar información de cada una de sus entidades dentro del mismo dominio (Clientes, Productos, Usuarios, etc) y al conjuntarse nace un concepto conocido como Object Relational Mapping (ORM).

NHibernate (NH) es un marco de trabajo ORM para ambientes en los que utilizamos .NET que nace de un port de Hibernate de Java y la gran utilidad es que ayuda a mapear los objetos de negocio que creamos en nuestras aplicaciones de .NET a bases de datos relacionales.

A partir de ahora intentaremos explicar cómo funciona a grandes rasgos NH y como podríamos aplicarlo a los nuevos desarrollos en la empresa. Para la práctica estaremos utilizando la versión 2008 del Visual Studio Team System (VSTS 2008) como IDE de desarrollo y la versión express del SQL Server 2005.

1. Crear un proyecto biblioteca de clases

Este proyecto deberá de contener nuestros objetos de negocio, y por lo tanto aquellos objetos que deseamos persistir. Como ya hemos mencionado en otros tutoriales, se recomienda como buena práctica crear un archivo de solución (sln) y en este agregar tantos proyectos vayamos a necesitar.

Para este tutorial he creado un proyecto llamado Tutorial.NH.BOL que es la biblioteca de clases que contendrá las entidades que representaran la base de datos.

2. Crear modelo de dominio

Nuestro modelo de dominio estará basado en usuarios (crearemos una carpeta con nombre Entidades en nuestro proyecto para depositar nuestras clases) y las diversas tareas que puede tener un usuario, sabemos que nuestras aplicaciones empresariales son más complejas, pero creo que bastará con explicar lo esencial para entender lo que es NH. La idea de esto es poder persistir estas entidades en nuestra base de datos relacional. Para hacer más sencillo el entendimiento de NH imagínense que una instancia de cada una de nuestras entidades en una fila de una tabla de la base de datos, pero no se casen con este concepto.

Es una buena práctica usar el diagramador de clases que por defecto cuenta el VSTS 2008, el trabajo es más limpio, mas controlado y lo mejor de todo en la mayoría de los casos ¡no tenemos que escribir código! =).

3. Crear modelo relacional

El modelo relacional estará representado por aquellas tablas de base de datos las cuales deberán de representar las entidades del modelo de dominio que queremos persistir. Ya sea en el IDE de VSTS 2008 o en la consola de Microsoft SQL Server deberemos de obtener algo como esto (algo ideal sería utilizar NH para generar el esquema de nuestra base de datos acorde a nuestro modelo de dominio, este método queda fuera del alcance del tutorial):

4. Mapeo ORM

La manera en cómo se mapeara el modelo de dominio con nuestro modelo relacional es a través de documentos XML, esto se hace con el fin de documentar la relación que existe entre nuestro objeto y la tabla que lo representa en la base de datos, es decir, el documento de configuración define que campos en la base de datos corresponden a los atributos en nuestro objeto y viceversa. La relación puede hacerse mediante código (con ayuda de la librería NHibernate.Mapping.Attributes.dll) en los atributos de la clase ó a través de archivos como los que acabo de comentar, archivos XML que tienen la extensión .hbm.xml, es por esto que nuestros archivos mapping deberan llamarse Usuario.hbm.xml y Tarea.hbm.xml. No hay que perder de vista que el .hbm es parte del nombre del archivo y es una convención que utiliza NH para identificar los archivos como mapping

Antes de empezar a trabajar con nuestro mapeo ORM debemos de descargar la versión 1.02 de NHibernate para .NET, la cual está disponible en la siguiente dirección: http://downloads.sourceforge.net/nhibernate/NHibernate-1.2.0.GA-bin.zip?modtime=1178204756&big_mirror=0

Se recomienza habilitar el Intellisense para el mapeo y la creación de estos archivos de configuración, para esto debemos de copiar los archivos nhibernate-configuration.xsd (para la configuración de las sesiones, algo que veremos más adelante en este tutorial) y nhibernate-mapping.xsd (para los mappings) a las carpetas de instalación de Visual Studio, \Common7\Packages\schemas\xml\ si usamos VS.NET 2003 y \Xml\Schemas\ para VS.NET 2005 y 2008.

Dentro de nuestra librería de clases Tutorial.NH.BOL vamos a crear una carpeta llamada Mapping -esto con el fin de tener mas orden- la cual contendrá todos nuestros archivos de configuración y la implementación de estos la muestro a continuación:

4.1. Usuario.hbm.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Tutorial.NH.BOL" namespace="Tutorial.NH.BOL">
    <class name="Usuario" table="usuarios">
        <id name="Id" column="IdUsuario" type="int" unsaved-value="0">
            <generator class="identity" />
        </id>
        <property name="Nombre" type="String" length="50"></property>
        <property name="ApellidoMaterno" type="String" length="50"></property>
        <property name="ApellidoPaterno" type="String" length="50"></property>
        <property name="CorreoElectronico" type="String" length="50"></property>
        <property name="Telefono" column="TelefonoParticular" type="String" length="50"></property>
        <bag name="Tarea" cascade="all-delete-orphan">
            <key column="IdUsuario" />
            <one-to-many class="Tarea" />
        </bag>
    </class>
</hibernate-mapping>

Ahora podemos hablar un poco sobre el contenido del archivo XML. Todos los documentos para mapear XML deberán de declarar el espacio de nombre urn:nhibernate-mapping-2.2 (depende de la versión distribuida), así como de manera opcional los atributos assembly para indicar el ensamblado de nuestras clases y el namespace de nuestras clases en el proyecto. Existen otros atributos aplicables a nuestro archivo como el schema, que representa el nombre del esquema de la base de datos, entre otros que están fuera del alcance de este tutorial. Una vez hecho esto debemos de comenzar a tratar los atributos y elementos para la clase que deseamos mapear. Dentro de las etiquetas estarán todas aquellas configuraciones para la clase. El atributo name corresponde al nombre de la clase incluyendo el nombre del assembly. El atributo table corresponde al nombre de la tabla en la base de datos.

Con la etiqueta representamos la llave primaria de la tabla de la base de datos. Este elemento define el mapeo entre la propiedad de la clase y la llave primaria de la base de datos. Entre sus atributos se encuentra el name, que indica el nombre del identificador de la propiedad; columna, que representa la columna en la tabla; type, el tipo de dato y el unsaved-value indica que el objeto es nuevo y que no existe en la base de datos.

Debemos de continuar con todas las propiedades, entonces Nombre, Apellido Paterno, Apellido Materno, Correo Electronico y Telefono deberán de estar dentro de las etiquetas y representan propiedades persistentes de la clase.

Y como habíamos dicho al inicio del tutorial, lo complicaremos creando una relación one-to-many con la clase Tarea y de esta forma representaremos la relación en la base de datos, es decir, que a un usuario se le pueden asignar varias tareas.

4.2. Tarea.hbm.xml

1
2
3
4
5
6
7
8
9
10

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Tutorial.NH.BOL" namespace="Tutorial.NH.BOL">
    <class name="Tarea" table="tareas">
        <id name="Id" column="IdTarea" type="int" unsaved-value="0">
            <generator class="identity" />
        </id>
        <property name="NombreTarea" type="String"></property>
        <many-to-one name="Usuario" column="IdUsuario" cascade="all" />
    </class>
</hibernate-mapping>

Lo único representativo es el elemento para la propiedad Usuario de nuestra clase. Esta representa una ordinaria asociación a otra clase persistente, en este caso la que tenemos en la base de datos.

Algo que debemos de saber es que en primera instancia NH está configurado de modo perezoso (lazy load) para todas las entidades creadas. Esto se recomienda dejarse así y no moverse. Debido a esto la regla es que todas las propiedades definidas en nuestras entidades deberán ser virtuales.

1
2
3
4
5

public virtual int Id
{
    get { return _id; }
    set { _id = value; }
}

Hay mucha más información relacionada a estos archivos mapping, pero sería algo complicado tratar de explicárselos paso a paso, además de que este tutorial perdería sentido, para ello, recomiendo consultar la referencia en línea sobre este mapeo de clases en http://www.hibernate.org/hib_docs/nhibernate/1.2/reference/en/html/mapping.html.

Hasta aquí nuestro explorador de soluciones deberá verse así:

5. Configurando NHibernate en VSTS 2008 .NET

Bueno hasta ahora, no hemos hecho mucho, pero ya empieza lo bueno =). Hay que decirle a NH con que proveedor de base de datos vamos a trabajar. Por fortuna NH soporta el más querido por nosotros en la oficina SQL Server.

Para hacer mas modular la aplicación, vamos a agregar una aplicación de consola a nuestra solución con el fin de consumir nuestro ORM. El nombre que yo le he puesto al proyecto es Tutorial.NH.App, tu puedes ponerle el que gustes. Importante agregar dentro de las referencias nuestro ensamblado de nombre Tutorial.NH.BOL. Pudimos haber utilizado Unit Test para probar nuestro proyecto en lugar de la aplicación de Consola, pero mejor eso veámoslo después.

5.1. Configuración en App.config

Agregaremos un archivo de configuración donde indicaremos las llaves necesarias para establecer la comunicación con nuestra base de datos.

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    </configSections>
    <nhibernate>
        <add key="hibernate.show_sql" value="false" />
        <add key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />
        <add key="hibernate.dialect" value="NHibernate.Dialect.MsSql2000Dialect" />
        <add key="hibernate.connection.driver_class" value="NHibernate.Driver.SqlClientDriver" />
        <add key="hibernate.connection.connection_string" value="Data Source=ROBERTO\SQLEXPRESS;Initial Catalog=NHibernate;Integrated Security=SSPI;" />
    </nhibernate>
</configuration>

5.2 Configuración en hibernate.cfg.xml

Este es otra manera de realizar nuestra configuración de NH y consiste en agregar un archivo XML a nuestro proyecto con la siguiente estructura: hibernate.cfg.xml.

1
2
3
4
5
6
7
8
9
10
11

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >
    <session-factory name="NH01">
        <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
        <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
        <property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>   
        <property name="connection.connection_string">Data Source=ROBERTO\SQLEXPRESS;Initial Catalog=NHibernate;Integrated Security=SSPI;</property>
        <property name="show_sql">false</property>
        <mapping assembly="Tutorial.NH.BOL" />
    </session-factory>
</hibernate-configuration>

Podemos utilizar cualquiera de los dos. Con este archivo de configuración le decimos a NH que queremos trabajar con Microsoft SQL Server como base de datos. Para nuestro ejemplo usaremos la segunda opción.

Y bien ya estamos listos para iniciar con nuestras operaciones CRUD.

6. Operaciones CRUD

Nuestro sistema hasta este punto ha sido preparado con lo esencial. Se han implementado características necesarias para el funcionamiento de NH, se ha creado el modelo de dominio se han definido los archivos mapping y se ha establecido la configuración a NH. Vamos poco a poco y ya llevamos algo recorrido =).

Empezaremos a darle uso y funcionalidad a nuestro dominio.

Ahora, vamos a agregar una carpeta a nuestro proyecto Tutorial.NH.BOL llamado Repositorio (esto lo especifica Domain Driven Design) y en el agregaremos una clase llamada IRepositorioUsuario.cs y la definimos de la siguiente manera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

using System;
using System.Collections.Generic;
using System.Text;
using Tutorial.NH.BOL.Entidades;
 
namespace Tutorial.NH.BOL.Repositorio
{
    public interface IRepositorioUsuario
    {
        void Agregar(Usuario usuario);
 
        void Actualizar(Usuario usuario);
 
        void Eliminar(Usuario usuario);
 
        Usuario ObtenerUsuarioPorId(int IdUsuario);
 
        IList<Usuario> ObtenerUsuarios();
    }
}

Ahora, lo que sigue es implementar cada uno de los métodos definidos por la Interface IRepositorioUsuario.cs. Comenzaremos con el primer método Agregar() que nos va a permitir agregar una instancia de un Usuario en nuestra base de datos.

Dentro de la misma carpeta (Repositorio) vamos a agregar una clase llamada RepositorioUsuario.cs y vamos a hacer que herede de la interfase IRepositorioUsuario.cs, con esto haremos que la clase implemente cada uno de los métodos de la interface.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

using System;
using System.Collections.Generic;
using System.Text;
using NHibernate;
using Tutorial.NH.BOL.Entidades;
using Tutorial.NH.BOL.Genericos;
 
namespace Tutorial.NH.BOL.Repositorio
{
    public class RepositorioUsuario : IRepositorioUsuario
    {
        public void Agregar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public void Actualizar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public void Eliminar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public Usuario ObtenerUsuarioPorId(int IdUsuario)
        {
            throw new NotImplementedException();
        }
 
 
        public IList<Usuario> ObtenerUsuarios()
        {
            throw new NotImplementedException();
        }
    }
}

Ahora, lo que sigue es crear el mecanismo para crear las sesiones que se van a comunicar con nuestra base de datos. Dentro del mismo proyecto, nos crearemos una Carpeta que nombraremos Genericos y agregamos una clase de nombre NHibernateClass.cs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NHibernate;
using NHibernate.Cfg;
 
namespace Tutorial.NH.BOL.Genericos
{
    public class NHibernateClass
    {
        private static ISessionFactory _sessionFactory;
        private static ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
                    var configuration = new Configuration();
                    configuration.Configure();
                    _sessionFactory = configuration.BuildSessionFactory();
                }
                return _sessionFactory;
            }
        }
 
        public static ISession OpenSession()
        {
            return SessionFactory.OpenSession();
        }
    }
}

Esta clase lo que hará por nosotros es crear una SessionFactory solo la primera vez que el cliente necesita una sesión. Que contiene este Singleton? Contiene un objeto del tipo Configuración que utiliza la configuración de nuestro hibernate.cfg.xml que creamos en la aplicación se escritorio y que se encarga de cargar el objeto ISessionFactory gracias al método BuildSessionFactory() y de esta forma poder comenzar a crear sesiones de tipo ISessionFactory.

Volvamos a nuestra clase RepositorioUsuario.cs e implementemos el método Agregar() de la siguiente manera:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Save(usuario);
        trans.Commit();
    }
}

En el método Actualizar() escribiremos lo siguiente:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Update(usuario);
        trans.Commit();
    }
}

En el método Eliminar() escribiremos lo siguiente:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Delete(usuario);
        trans.Commit();
    }
}

Para el método ObtenerUsuarioPorId() haremos esto:

1
2
3
4
5

public Usuario ObtenerUsuarioPorId(int IdUsuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
        return sesion.Get<Usuario>(IdUsuario);
}

Y para obtener todos los usuarios:

1
2
3
4
5
6
7
8

public IList<Usuario> ObtenerUsuarios()
{
    using (ISession sesion = NHibernateClass.OpenSession())
    {
        var usuarios = sesion.CreateCriteria(typeof(Usuario)).List<Usuario>();
        return usuarios;
    }
}

Nota la creación del objeto sesión desde nuestra clase NHibernateClass.cs y tambien el uso de una transacción.

¡Y listo! podemos empezar a trabajar con nuestro modelo de NH para la persistencia de nuestras entidades de dominio.

Para guardar la información de un usuario y sus tareas una posible implementación es que desde nuestra aplicación de consola incluyamos esta implementación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Tutorial.NH.BOL.Entidades;
using Tutorial.NH.BOL.Repositorio;
 
namespace Tutorial.NH.App
{
    class Program
    {
        static void Main(string[] args)
        {
            Usuario usr = new Usuario();
            usr.Nombre = "Roberto";
            usr.ApellidoPaterno = "Ramirez";
            usr.ApellidoMaterno = "Leyva";
            usr.CorreoElectronico = "jramirezleyva@gmail.com";
            usr.Telefono = "410-00-00";
 
            Tarea task = new Tarea();
            task.NombreTarea = "Tutorial de NHibernate";
            task.Usuario = usr;
            usr.Tarea.Add(task);
 
            IRepositorioUsuario rUsr = new RepositorioUsuario();
 
            rUsr.Agregar(usr);                      
        }
    }
}

Si bien recordamos cuando hicimos el modelo de dominio y las mapeamos con la base de datos, creamos unas propiedades que permitían las relaciones , . Esta es la verdadera magia, se dieron cuenta que nunca utilizamos procedimientos almacenados? o que nunca nos creamos rutinas de conexión y de creación de DataAdapters? o DataSets? mucho menos DataReaders? Gracias a NH podemos persistir nuestros objetos de una manera limpia y orientada a objetos que es lo más importante.

Conclusión

En este sencillo ejemplo, pudimos observar cómo manejar un modelo de dominio y como cerrar el “gap” con nuestra base de datos relacional. Sabemos que este es un ejemplo básico y hay mucho más que explicar y que probar, pero por lo pronto espero que esto les haya servido como una introducción (al menos a mí si me ayudo jeje).

El código de ejemplo lo pueden descargar de aqui.

Mas información:

http://www.hibernate.org/hib_docs/nhibernate/1.2/reference/en/html/
http://darioquintana.com.ar/articles/tutorial-de-nhibernate-primeros-pasos

Una vez fui de los que pensé que esta serie de programas académicos dirigidos a formar profesionales que propongan proyectos de TI y así satisfacer necesidades, no era para mí, no era lo que yo buscaba, pero es de sabios rectificar y ahora puedo decir que me siento orgulloso de pertenecer a este grupo de profesionales. Fueron mis maestros (agradecimiento especial a cada uno), las experiencias de todos y cada uno de los que alguna vez levantamos la mano para hacer una pregunta en alguna clase y qué decir de las tareas, lo que me ayudo a cambiar de parecer.

Lo último que puedo decir es que aun tengo mucho que mejorar y esto no se acaba aquí, hay mucho aprendizaje de por medio, muchas más ramas del área que explorar y algo mucho más importante, aplicar todo lo que he aprendido.

Aun tengo algunos pendientes. Uno de ellos es la clase de este jueves y por ultimo pero no menos importante, terminar el documento que me acredite como Maestro en Administración de TI (la famosa tesis), que va en buen camino por cierto.

Agradecimiento a la niña que contribuyó en todo momento en apoyar a su servidor en este reto, sin duda fuiste una parte muy importante en este proyecto de maestría, muchas gracias Alejandra ♥

Después de conocer que esta herramienta viene integrada en la versión Team System de Visual Studio .NET 2008 (en realidad ya venía integrada desde versiones anteriores) en la empresa donde laboro decidieron ajustar las reglas o estándares de codificación internas utilizadas, a todo aquel ensamblado generado en los proyectos.

El objetivo era generar código estandarizado y que mejor que el Code Analysis para lograrlo y usarlo para crear políticas de generación de buils, es decir, no permitir compilar el proyecto si no cumplimos con los estándares internos.

A partir de este párrafo verán algo de lo que pude realizar para crear una regla de análisis de código que verifique el nombramiento de los elementos de interfase grafica.

1. Crear biblioteca de clases

Nuestro primer paso será de los más sencillo, crear un proyecto de tipo biblioteca de clases que contendrá las clases que define la regla para verificar el nombramiento de los elementos de interfase grafica de nuestras aplicaciones (es una buena práctica definir un archivo de tipo solución de proyecto y en esta ir agregando todos los proyectos que necesitemos).

2. Agregar referencias

Debemos de incluir nuestras referencias a la librería de FxCop que se encuentra dentro de la ruta: Archivos de programa\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop (podria variar dependiendo del idioma y sistema operativo y al menos en un XP en español es la misma). Estas representan el framework que contiene las clases necesarias para poder diseñar nuestra regla.

• FxCopSdk.dll. Para acceder a la interfase IIntrospectionRule que permitirá identificar aquellas clases de ensamblados que son reglas de Code Analysis, que implementa la clase BaseIntrospectionRule.
• Microsoft.Cci.dll.

3. Crear la clase base

Para poder implementar los métodos de la interfase IIntrospectionRule, es necesario crearnos una clase abstracta (que nosotros llamaremos BaseRule) que herede o implemente la clase BaseIntrospectionRule. Más o menos quedaría así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.FxCop.Sdk;
using Rules.Naming.Globales;
 
namespace Rules.Naming
{
    public abstract class BaseRule : BaseIntrospectionRule
    {
        protected BaseRule(string name) : base(name, Constantes.Config_Rules, typeof(BaseRule).Assembly) { }
    }
}

Noten que he agregado una clase (Constantes.cs) que contendrá aquellas variables constantes para nuestra regla. Yo ahí he colocado la variable que representara nuestro archivo de recursos (un archivo xml, pero aun no te preocupes por conocerlo, mas adelante lo podrás observar).

1
2
3
4
5
6
7
8
9
10
11
12
13

namespace Rules.Naming.Globales
{
    /// <summary>
    /// Clase estática que contiene los valores constantes.
    /// <summary>
    public static class Constantes
    {
        /// <summary>
        /// El nombre del recurso embebido. Xml que contiene las reglas.
        /// <summary>
        public const string Config_Rules = "Rules.Naming.Rules";
    }
}

4. Crear la regla de Code Analysis

Bien, ¡estamos listos para crear nuestra regla!, habíamos comentado que nuestra regla validaría el nombramiento de elementos de interfase grafica de nuestras aplicaciones, entonces como primer punto debemos de agregar una clase nueva a nuestro proyecto (es una buena práctica nombrar a la clase con un nombre que haga referencia a la regla). Nuestra clase se llamara VerifyGUINaming.cs y la definición se muestra a continuación.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.FxCop.Sdk;
 
namespace Rules.Naming
{
    /// <summary>
    /// Esta clase nos permitirá diseñar una regla para realizar análisis de código
    /// a los elementos de interfase gráfica de la aplicación.
    /// <summary>
    public class VerifyGUINaming : BaseRule
    {
        public VerifyGUINaming() : base("VerifyGUINaming") { }
    }
}

Como se puede observar lo primero que tenemos que hacer es agregar la referencia a nuestra biblioteca de clases de FxCop y después hacer que la misma herede de la clase base (BaseRule.cs) que hemos definido (no olviden documentar todo lo que hagan). Hasta aquí ya se encuentra definida la regla, pero aun no hace nada jojojo!.

5. Implementando el metodo Check()

Empecemos con lo nice de esto. Debemos de implementar el método Check() que contiene la clase BaseIntrospectionRule que permitirá reportar cualquier problema (¿recuerdan al inicio del tutorial? ) referente a la definición y los deposita dentro de una clase ProblemCollection.

Nuestro código para verificar el nombramiento de un elemento de escritorio de tipo Button deberá de verse así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

        /// <summary>
        /// Método que agrega a la colección de problemas en caso de no cumplirse la regla.
        /// <summary>
        /// <param name="member">Elemento a comparar.</param>
        /// <returns>Un problema en caso de haberlo.</returns>
        public override ProblemCollection Check(Member member)
        {
            Field campo = member as Field;
            if (campo != null)
            {
                string nombreControl = campo.Type.FullName;
                if (nombreControl.StartsWith("System.Windows.Forms.Button"))
                {
                    if (!campo.Name.Name.StartsWith("btn_"))
                    {
                        Problems.Add(new Problem(GetResolution("btn_", "System.Windows.Forms.Button", campo.Name.Name)));
                    }
                }
               else
                {
                    return null;
                }
            }
            else
            {
                return null;
            }
 
            return Problems;
        }

Si aun no sabes que es lo que recibe como parámetro (member) el método Check, entonces te puedo comentar que ese tipo representa los miembros que puede tener una clase, métodos, propiedades, eventos, delegados, etc. Existen otros elementos que analiza el método Check, pero como ya he escrito mucho sobre esto, tendrás oportunidad de echar un googlazo e investigar por tu cuenta.

6. Creando el esquema XML

Para dejar completa nuestra regla es necesario crear nuestro archivo XML que describirá información relacionada a aquellos problemas encontrados al momento de analizar el código del ensamblado, en otras palabras, el código mostrado determina si hay un problema, el archivo XML lo describe de mejor forma.

Como primer paso habrá que agregar a nuestro proyecto un archivo con extensión xml y escribir lo siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="utf-8" ?>
<Rules FriendlyName="Code Analysis Rules">
  <Rule TypeName="VerifyGUINaming" Category="Rules.Naming" CheckId="NR0001">
    <Name>Nombramiento de elementos de interfase gráfica</Name>
    <Description>Para el nombramiento de los elementos de interfase gráfica el identificador del control se deberá escribir en minúscula anteponiendo al identificador un prefijo que indique el tipo de elemento grafico que es separado por un guión bajo. Esto ayudara a distinguir los elementos de interfase grafica.</Description>
    <Url></Url>
    <Resolution>Reemplazar el identificador del control "{2}" por su correcto nombramiento de interfase gráfica: "{0}".</Resolution>
    <MessageLevel Certainty="95">Error</MessageLevel>
    <FixCategories>Breaking</FixCategories>
    <Email>jramirezleyva@gmail.com</Email>
    <Owner>Roberto Ramírez</Owner>
  </Rule>
</Rules>

El nombre del recurso si bien recuerdan lo definimos en nuestra clase Constantes.cs y se indica en la clase base BaseRule.cs

Algo muy importante es decirle a nuestro proyecto que este archivo de reglas XML deberá de comportarse como un recurso embebido a nuestro ensamblado.

7. Usando nuestra regla de análisis de código

Hasta este paso lo que obtenemos como resultado es un ensamblado que contiene la definición de nuestra regla, y lo que debemos de hacer es probarla.

Para que esto sea posible debemos manualmente copiar nuestra regla (ensamblado) al folder de nuestra versión de Visual Studio, como el titulo dice que es para la versión VSTS 2008 nuestro folder se encuentra en esta dirección: C:\Archivos de programa\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop\Rules, normalmente lo único que cambia es la versión del Visual Studio.

Una vez finalizado esto, cerramos y abrimos nuestro Visual Studio. Tu puedes crear un nuevo proyecto a agregarlo a la solución para hacer la prueba de análisis de código, en este caso puedes agregar un proyecto de escritorio para revisar el elemento de interfase grafica Button.

Ya que tengamos nuestro proyecto veremos sus propiedades y en la pestaña de análisis de código (Code Analysis) veremos algo muy similar a esto:

Dando por hecho que en nuestra aplicación de escritorio de prueba tenemos un botón sin el prefijo “btn_” en la forma y corriendo el Code Analysis en nuestra aplicación podemos ver lo siguiente:

Nota que lo que nos arroja el análisis de código en un problema de tipo Warning, dejando que nuestro proyecto compile, si al inicio hablamos de código estandarizado entonces deberemos de configurar nuestra aplicación para que no compile en caso de no cumplirse las reglas. Para esto lo único que debemos de hacer es darle a la regla un trato de error en nuestro archivo XML y en la configuración de las propiedades del proyecto habilitar las opciones de “Manejar la regla como error” y “Habilitar Code Analysis en el Build” como se muestra en la imagen:

Con esto no permitiremos compilar código si antes no cumplimos con nuestras reglas.

Espero que esto los ayude.