Espacio de Dario Quintana

En este post estaba adelantando algo que estoy empezando a hacer, por ahora bosquejando y pensando, sin embargo…hay algo funcional para ir pispeando.

La idea es crear un "puente" entre NHibernate y diferentes frameworks para validar nuestras entidades de negocio. Hay quienes les gusta validar solamente en la entrada, otros en la capa de negocio, otros en la capa de acceso a datos, u otros en todos lados! Este "approach" intentará validar en la capa de Acceso a datos, justo antes de que NHibernate realice un Save/Update (y por que no un Delete?).

Por ahora, pueden encontrar el código disponible para usar haciendo un checkout de SVN de uNHAddIns. Consta de un proveedor para usar el validador del Enterprise Library Application Block . Después veremos que otros frameworks podemos inyectar (para eso necesito sus sugerencias).

Como pueden ver en este test, NHibernate arroja una excepción si alguien intenta guardar una entidad no válida. Créanme que arroja luz verde.

[Test,ExpectedException(typeof(ValidationException))]
public void InsertWithInvalidEntity() {

    using (ISession s = sf.OpenSession())
    {
        using (ITransaction tx = s.BeginTransaction())
        {
            s.Save(GetNoValidFoo());
            tx.Commit();
        }
    }
}

Para poder configurar este escenario es necesario una configuración previa como esta:

cfg = new Configuration();
cfg.SetProperty(Environment.HibernateValidationProvider,
                typeof(EntLibValidator).AssemblyQualifiedName);

ValidateEventListener validateEventListener = new ValidateEventListener();
cfg.SetListener(ListenerType.PreInsert, validateEventListener);
cfg.SetListener(ListenerType.PreUpdate, validateEventListener);

cfg.Configure();

sf = cfg.BuildSessionFactory();

El EventListener ValidateEventListener hace el trabajo de intercepción antes de las operaciones Insert/Update, de ese modo es como podemos hacer el trabajo de validación.

Esto es un borrador, que por cierto funciona, así que puede cambiar. Todo comentario es más que bienvenido.

Para hacer checkout de el código fuente:

http://unhaddins.googlecode.com/svn/branches/NHTrunk/

Un nuevo Application Block nació: Policy Injection Application Block.

Al parecer, con este nuevo App Block podremos aplicar conceptos como el de SoC (Separation of concerns) en nuestra aplicación, tal como lo venían predicando de manera similar frameworks como Spring.Net.

Para ser claro, podriamos hacer que en un objeto de nuestra aplicación, al ejecutarse un método, realice una entrada al archivo de log, de forma transparente en el código cliente. 

Esto se pone más interesante, en la interoperabilidad que podremos llegar a tener con otros App Blocks, como ser: Validation, Logging, Exception entre otros.

La idea básica es trabajar con una factoría de clases, para la instanciación de nuestros objetos. Dicha factoria inspeccionará la configuración, para ver si el objeto posee politicas que aplicar, si no las posee, se crea una instancia común y corriente, si las posee, se crea un proxy para que el framework pueda manejar al objeto de forma transparente al cliente.

Escenario donde podriamos aplicar:

En nuestra aplicación un objeto que posee un método Guardar(Cliente obj). Utilizando estos conceptos, podríamos hacer que cada vez que se llame a este método, es decir, que querramos guardar un cliente, por medio del Policy Injection App Block se realize la validación del objeto (utilizando el Validation App Block), y si no es una entidad válida, dicho método Guardar no se ejecute.

Para más lean estos posts:

• Announcing the Policy Injection Application Block
• Policy Injection App Block - Behind the Scenes