Sabemos hoy en día que la mayoría de las empresas basan sus aplicaciones en software analizado, diseñado y programado orientado a objetos. La empresa donde trabajo, los últimos meses se ha preocupado porque que cada vez en los desarrollos que se venden se utilicen objetos para crear modelos de negocio, que con esto, sin duda si creamos un modelo de dominio orientado a objetos será más claro el negocio para que el que lo necesite entender y código fácil mucho mas mantenible para los programadores que lo vayan a modificar.

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 <VS .NET directorio de instalación>Common7Packagesschemasxml si usamos VS.NET 2003 y <VS 2005 directorio de instalación>XmlSchemas 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 <class name=”Usuario”></class> 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 <id> 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 <property/> 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 <many-to-one> 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=ROBERTOSQLEXPRESS;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=ROBERTOSQLEXPRESS;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 interfaz 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 interfaz IRepositorioUsuario.cs, con esto haremos que la clase implemente cada uno de los métodos de la interfaz.

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
32

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 <many-to-one />, <one-to-many />. 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

Inspirado en un post del Guamu no quise dejar de comentar acerca de lo que represento en su momento la maestría en mi vida, y es que no es para menos, fueron ¡dos años! y si no fueron intensos, si ayudaron para reflexionar sobre el rumbo de mi vida, en donde me encuentro actualmente y hacia donde me dirijo.

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 ♥

FxCop es una herramienta Open Source que ayuda al análisis de ensamblados de código mediante reglas y reporta información relacionada de esos ensamblados, la cual puede referirse a rubros como el de seguridad, diseño, rendimiento, todo aquello relacionado a reglas aplicables a los ensamblados (para mas información).

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 interfaz 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 interfaz 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 interfaz 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 interfaz 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 interfaz 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 interfaz 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 interfaz gráfica</Name>
    <Description>Para el nombramiento de los elementos de interfaz 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 interfaz grafica.</Description>
    <Url></Url>
    <Resolution>Reemplazar el identificador del control "{2}" por su correcto nombramiento de interfaz 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 interfaz 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.

Después de muchos estire y afloja, parece que al fin ya tengo claro todo lo que deberé de hacer para obtener mi grado de MATI, espero que esto siga así y no toparme de nuevo con pared y volver a modificar el alcance, que dicho sea de paso, es complicado poder estructurar algo cuando le están cambie y cambie el mismo.

Saludos desde diagnósticos, técnicas, actividades propias de consultoría de empresas y mucha, pero mucha documentación!

Los que me conocen se darán cuenta de que el titulo de mi post no se refiere a las aplicaciones web que se empaquetan o que satisfacen necesidades especificas para algún modelo de negocio o empresa como tal; aplicaciones que pueden desarrollarse con algún IDE como el de VS.NET (esa mas bien es mi chamba). Más bien me refiero a las aplicaciones web que empresas como Google, Hotmail, entre otras ofrecen y que ponen a disposición de aquel que las requiera. Algunas personas las han de conocer como la Web2.0.

De un tiempo acá me he convertido en todo un friki buscando la mejor forma de darle uso a dichas aplicaciones. Me he obsesionado al grado de querer tener a la mano toda la información relacionada a mi vida diaria a través de la red.

Ya tengo conmigo un buen palmarés de estas aplicaciones las cuáles siento que me han servido de mucho y que no me han permitido preocuparme por no tener al alcance la información que requiero para seguir con mis labores:

• Google Mail: Lo he convertido en mi cliente de correos predeterminado. Aquí recibo correos tanto de mi oficina, como personales, los cuales puedo clasificar fácilmente gracias al motor de etiquetas y filtros con la que cuenta la herramienta.

• Remember The Milk: Mi gestor de tareas o cosas por hacer predilecto. Aquí coloco todas aquellas tareas o cosas que tengo pendientes por hacer. Ahora esta herramienta la tengo integrada al Google Mail contando con una poderosa herramienta de productividad siempre conmigo.

• Google Reader: Mi lector de feeds por excelencia. Podría decirse que aquí es donde me entero de aquellas nuevas prácticas relacionadas al área de TI e Ingeniería de Software, y alguno que otro blog amigo por supuesto.

• Google Calendar: Mi calendario online por default. Al prescindir de una herramienta como Microsoft Outlook, requiero de algún método para agendar mis citas, reuniones y vida personal, Google Calendar me ofrece todo lo mencionado, sin dejar de mencionar que puedo consultarlo donde yo lo desee.

• Sky Drive de Windows Live: Mi método para almacenamiento online de cajón. Aquí puedo colocar y gestionar archivos tal cual fuera un FTP. Vaya si está disponible porque no usarlo!!

• Google Docs: Siguiendo con Google, el lugar donde se localiza mi mayor parte de información relacionada a tecnologías, lenguajes de programación, etc. Tenemos la opción de poder trabajar esta aplicación aun cuando no tengamos una conexión a internet, gracias a Google Gears.

• Google Bookmarks: Sobra explicar esto. Mis Bookmarks en línea (:

• Picassa Web: Un lugar para almacenar mis fotografías.

Estas herramientas se han convertido en imprescindibles para un día normal de trabajo e investigación y me encanta poder gestionar mi vida informática desde ellas. Lo mejor es que estarán disponibles para miguelito siempre y cuando cuente con una conexión a internet.

Saludos desde aquí para allá!

Hummm, nada mal siento yo …. (:

43% Geek

Created by OnePlusYou

La semana que acaba de pasar me ha resultado muy provechosa, particularmente en mi comprensión sobre algunas tecnologías de desarrollo de Microsoft y tomando en cuenta que en mi actual trabajo es el pan de todos los días el desarrollar software con estas, pues en este primer intento de acercamiento, he quedado muy satisfecho por muchos aspectos. Uno de estos aspectos es que el cuate que nos visito y nos dio el overview del VSTS.2008 nos ha dejado con un buen sabor de boca, al menos conmigo en lo particular si lo hizo. Segundo, la herramienta viene a darnos o mas bien viene a revolucionar creo yo en mi humilde punto de vista la manera en como desarrollamos el software en la empresa. Es mucho el potencial que tenemos al alcance con esta herramienta y sabiendola utilizar es muy seguro que podremos mejorar nuestros hábitos de programación.

Los tags de la presentación: sqlinjection, blindsqlinjection, vsts2008, nhibernate, nunit, unittest, importaciadelaspruebasunitarias, linq, microsoft, firefox3, deployment, df, novutek, dotnet, seguridad, iis, desarrolloguiadosporpruebas, refactoring, workitem, codesecurity, reflection, fxcode, performance, tipos de pruebas, desarrollo, basededatos, sonora, 50°C, soa, sqlserver2008, codeanalisis, mejorespracticas, teamfoundationserver, wfs, controldeversiones.

Por ahi se me pasaron varios, pero son los que se me vienen a la mente.