The Dot Sharper

Uno de los problemas más frecuentes con lo que nos encontramos a la hora de utilizar NHibernate, son las diferencias entre el modelo de domino y el modelo relacional de la base de datos, de forma que a veces es muy difícil relacionar algunas entidades del modelo de dominio con las tablas de la base de datos. Estas diferencias, se convierten con mucha facilidad en problemas de rendimiento, ya que las consultas que se generan no son todo lo optimas que deberían ser. En muchas ocasiones estas diferencias se vuelven insalvables, y se pierde mucho tiempo (dinero) en intentar solucionar algo que sencillamente no tiene arreglo.

Mi recomendación, siempre es la misma, primero se debe construir el dominio, siguiendo siempre los principios del Domain Driven Design, y luego a partir del dominio generar la base de datos, de forma que esas diferencias entre el domino la base de datos sean lo menor posible.

En este aspecto, NHibernate nos puede ayudar a generar la base de datos a partir de los ficheros de mapeo de la siguiente forma:

    var configuration = new Configuration();
    configuration.Configure(fileConfiguration);

    using (var sessionFactory = configuration.BuildSessionFactory())
    using (var session = sessionFactory.OpenSession())
    {
        var generateSchemaCreationScript = configuration.GenerateSchemaCreationScript(new MsSql2008Dialect());
        foreach (var script in generateSchemaCreationScript)
        {
            var sqlQuery = session.CreateSQLQuery(script);
            sqlQuery.ExecuteUpdate();
        }
    }

Por otro lado, durante el ciclo de vida de un proyecto, el modelo de dominio va evolucionando en el tiempo y el espacio, y normalmente resulta bastante tedioso la creación de los scripts SQL de creación y modificación de la base de datos. Con NHibernate también podemos generar los scripts diferenciales entre la base de datos y el modelo de dominio de la siguiente forma:

    var configuration = new Configuration();
    configuration.Configure(fileConfiguration);

    using (var sessionFactory = configuration.BuildSessionFactory())
    using (var session = sessionFactory.OpenSession())
    {
        var meta = new DatabaseMetadata((DbConnection)session.Connection, new MsSql2008Dialect());
        var generateSchemaCreationScript = configuration.GenerateSchemaUpdateScript(new MsSql2008Dialect(), meta);
        foreach (var script in generateSchemaCreationScript)
        {
            var sqlQuery = session.CreateSQLQuery(script);
            sqlQuery.ExecuteUpdate();
        }
    }

Si nos encontramos que tenemos un problema de diferencia entre el modelo de domino y la base de datos, es un buen ejercicio generar los scripts diferenciales, para poder ver que lejos (o cerca) estamos de lo que deberíamos tener. Si las diferencias son muy grandes, es muy posible que este script no nos sea de mucha ayuda.

La implementación que uso para la generación del esquema de la base de datos es la siguiente:

    using System;
    using System.Collections.Generic;
    using System.Data.Common;
    using NHibernate;
    using NHibernate.Cfg;
    using NHibernate.Dialect;
    using NHibernate.Tool.hbm2ddl;

    public class NHibernateSchemaHelper : INHibernateSchemaHelper
    {
        private readonly ISessionFactory _sessionFactory;
        private readonly ISession _session;
        private readonly Configuration _configuration;

        public NHibernateSchemaHelper()
        {
            _configuration = new Configuration();
            _configuration.Configure();

            _sessionFactory = _configuration.BuildSessionFactory();
            _session = _sessionFactory.OpenSession();
        }

        public NHibernateSchemaHelper(string fileConfiguration)
        {
            _configuration = new Configuration();
            _configuration.Configure(fileConfiguration);

            _sessionFactory = _configuration.BuildSessionFactory();
            _session = _sessionFactory.OpenSession();
        }

        public void Create()
        {
            Drop();
            var generateSchemaCreationScript = _configuration.GenerateSchemaCreationScript(new MsSql2008Dialect());

            ExecuteSchemaScript(generateSchemaCreationScript);
        }

        public void Update()
        {
            var meta = new DatabaseMetadata((DbConnection)_session.Connection, new MsSql2008Dialect());
            var generateSchemaCreationScript = _configuration.GenerateSchemaUpdateScript(new MsSql2008Dialect(), meta);

            ExecuteSchemaScript(generateSchemaCreationScript);
        }

        public void Drop()
        {
            var generateSchemaCreationScript = _configuration.GenerateDropSchemaScript(new MsSql2008Dialect());

            ExecuteSchemaScript(generateSchemaCreationScript);
        }

        private void ExecuteSchemaScript(IEnumerable generateSchemaCreationScript)
        {
            foreach (var script in generateSchemaCreationScript)
            {
                var sqlQuery = _session.CreateSQLQuery(script);
                sqlQuery.ExecuteUpdate();
            }
        }

        public void Dispose()
        {
            GC.SuppressFinalize(this);
            Dispose(true);
        }

        private void Dispose(bool disposing)
        {
            if (disposing)
            {
                _session.Dispose();
                _sessionFactory.Dispose();
            }
        }
    }

    public interface INHibernateSchemaHelper : IDisposable
    {
        void Create();
        void Update();
        void Drop();
    }

Como podéis ver, Nhibernate nos ayuda a generar el schema de la base de datos, y a que las diferencias entre el dominio y la base de datos sean las menores posibles, lo que significa que nuestro dominio está replicado en al base de datos, y que los problemas ocasionados por los intentos de adaptación del dominio a la base de datos no los vamos a tener.

Esto no nos va a eliminar los problemas de rendimiento ocasionados por un mal dominio, esos lamentablemente los seguiremos teniendo, NHibernate no es tan listo, como decía Botines: “La programasión es un arte,… sino programarían los roboses”.

Al trabajar con ASP.Net MVC podríamos pensar que no podemos utilizar la inyección de dependencias, ya que cuando se produce una petición web, ASP.Net MVC crea automáticamente las instancias de los controladores. Y que la única forma de poder utilizar la inyección de dependencias sería, llamar al contenedor directamente en el constructor por defecto del controlador.

Por defecto, ASP.Net MVC para crear los controladores utiliza una instancia de la clase DefaultControllerFactory, y esta necesita que los controladores tengan el constructor por defecto. Por suerte, podemos crear nuestra propia factory, especificarle al MVC que factory queremos que utilice, siempre y cuando herede de DefaultControllerFactory .

Así que lo primero que tenemos que hacer es crear nuestra clase ControllerFactory:

public class WindsorControllerFactory : DefaultControllerFactory
    {
        /// <summary>
        /// Gets the controller instance.
        /// </summary>
        /// <param name="requestContext">The request context</param>
        /// <param name="controllerType">Type of the controller.</param>
        /// <returns>A reference to the controller.</returns>
        protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
            {
                throw new HttpException(404, string.Format("The controller for path '{0}' could not be found or it does not implement IController.",
                    requestContext.HttpContext.Request.Path));
            }
            return (IController)WindsorContainerHelper.Instance.Resolve(controllerType);
        }

        /// <summary>
        /// Releases the controller.
        /// </summary>
        /// <param name="controller">The controller.</param>
        public override void ReleaseController(IController controller)
        {
            var disposableController = controller as IDisposable;
            if (disposableController != null)
            {
                disposableController.Dispose();
            }
            WindsorContainerHelper.Instance.Release(controller);
        }
    }

Como podéis ver, estoy utilizando un helper para acceder a Windsor Container, que yo mismo es creado, y que me permite cargar la configuración y utilizar el contenedor de forma mas fácil. Pero esto será un tema para otro post.

Lo realmente importante de esta clase son los dos métodos que tenemos que sobrescribir, GetControllerInstance y ReleaseController, el primero es que al que llama MVC para crear una instancia del controlador a partir del tipo, nosotros hemos sobrescrito el método para delegar la creación de la instancia al Windsor Container. El segundo se producirá cuando acabe la petición Web, y es el método al que llama el MVC para liberar el controlador, en este caso sobrescribimos el método para eliminar la instancia del contenedor.

Por último, necesitamos que el MVC utilice nuestro ControllerFactory, para esto lo que tenemos que hacer es especificarlo cuando se inicie la aplicación, es decir, en el Global.asax pondremos la siguiente linea:

protected void Application_Start()
        {
            ...
            ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory());
            ...
        }

Come veis es muy fácil inyectar las dependencias directamente en el controlador MVC.

public Customer FindById(int id)
{
    try
    {
        return repository.FindById(id);
    }
    catch()
    {
        return null;
    }
}

/// <summary>Devuelve el cliente con el identificador especificado.
/// Si el identificador no existe devuelve null.</summary>
/// <param name="id">Debe ser > 0</param>
public Customer FindById(int id)
{
    return repository.FindById(id);
}

Diseño por Contrato

public Customer FindById(int id)
{
    if(repository == null)
        throw new Exception("Error en el repositorio");

    if(id <= 0)
        throw new ArgumentOutOfRangeException("El id debe ser mayor que 0");

    var customer = repository.FindById(id);

    if(customer == null)
        throw new KeyNotFoundException(string.Format("No se ha encontrado un cliente con el ID: {0}", id));

    return customer;
}

Validación por Aspectos

[NotNull]
public Customer FindById([GreaterThan(0)]int id)
{
    return repository.FindById(id);
}

Introducción

Creado Test Unitarios

public class CustomerBusiness
{
    private const string SPECIAL_FARE = "SPC";

    private readonly ICustomerDao customerDao;

    public CustomerBusiness(ICustomerDao customerDao)
    {
        this.customerDao = customerDao;
    }

    public bool HasSpecialFare(Customer customer)
    {
        return customerDao.GetFareType(customer).Type
                             == SPECIAL_FARE;
    }
}

public interface ICustomerDao
{
    FareType GetFareType(Customer customer);
}
...

[TestFixture]
public class CustomerBusinessTest
{
    [Test]
    public void HasSpecialFareTest()
    {
        //Creación de los objetos mocks
        var mockRepository = new MockRepository();
        var customerDaoMock =
              mockRepository.CreateMock<ICustomerDao>();

        //Establecimiento de las llamadas esperadas
        //y de los objetos de retorno
        var customer = new Customer();
        var fareType = new FareType
                 {Type = CustomerBusiness.SPECIAL_FARE};
        Expect.Call(customerDaoMock.GetFareType(customer))
                                 .Return(fareType);

        mockRepository.ReplayAll();

        var customerBusiness =
                 new CustomerBusiness(customerDaoMock);
        var specialFare =
                 customerBusiness.HasSpecialFare(customer);
        mockRepository.VerifyAll();
        Assert.IsTrue(specialFare);
    }
}

Introducción

Interfaces

public interface ISumador
{
   decimal Suma(decimal num1, decimal num2);
}

public class Sumador : ISumador
{
    public decimal Suma(decimal num1, decimal num2)
    {
        return num1 + num2;
    }
}
...
public static WindsorContainer miContenedor;
public static void Main(string[] args)
{
    //Creamos el contenedor
    miContenedor = new WindsorContainer
                (new XmlInterpreter("MiContenedor.xml"));

    //Pedimos un objeto de tipo sumador al contenedor
    var sumador = miContenedor.Resolve<ISumador>();

    var result = sumador.Suma(1,1);
}
...

<configuration>
    <components>
        <component id="Sumador" type="IoC.Tutoriales.Part2.Sumador, IoC.Tutoriales.Part2"
            service="IoC.Tutoriales.Part2.ISumador, IoC.Tutoriales.Part2" />
    </components>
</configuration>

Dependencias entre componentes

public interface ILogger
{
    void Debug(string text);
}

public class FileLogger : ILogger
{
    private string fileName;

    public FileLogger(string fileName)
    {
        this.fileName = fileName;
    }

    public void Debug(string text)
    {
        //Graba el texto en el fichero fileName
        ....
    }
}

public class Sumador
{
    private ILogger logger;

    public Sumador(ILogger logger)
    {
        this.logger = logger;
    }
    public decimal Suma(decimal num1, decimal num2)
    {
        logger.Debug(string.Format("Sumando {0} + {1}",
                                        num1, num2));
        return num1 + num2;
    }
}

public static void Main(string[] args)
{
    var logger = new FileLogger("log.txt");
    var sumador = new Sumador(logger);
    var result = sumador.Suma(1,1);
}

<configuration>
    <components>
        <component id="Sumador" type="IoC.Tutoriales.Part2.Sumador, IoC.Tutoriales.Part2"
            service="IoC.Tutoriales.Part2.ISumador, IoC.Tutoriales.Part2" />
        <component id="Logger" type="IoC.Tutoriales.Part2.FileLogger, IoC.Tutoriales.Part2"
            service="IoC.Tutoriales.Part2.ILogger, IoC.Tutoriales.Part2">
           <parameters>
               <fileName>C:\log.txt</fileName>
           </parameters>
        </component>
    </components>
</configuration>

public static void Main(string[] args)
{
    //Creamos el contenedor
    miContenedor = new WindsorContainer(
                 new XmlInterpreter("MiContenedor.xml"));

    //Pedimos un objeto de tipo sumador al contenedor
    var sumador = miContenedor.Resolve<ISumador>();

    var result = sumador.Suma(1,1);
}

Un pequeño refactoring

public class DBLogger : ILogger
{
    private string connectionString;

    public DBLogger(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public void Debug(string text)
    {
        //Graba el texto en la base de datos
        ....
    }
}

<configuration>
    <components>
        <component id="Sumador" type="IoC.Tutoriales.Part2.Sumador, IoC.Tutoriales.Part2"
            service="IoC.Tutoriales.Part2.ISumador, IoC.Tutoriales.Part2"/>
        <component id="Logger" type="IoC.Tutoriales.Part2.DBLogger, IoC.Tutoriales.Part2"
            service="IoC.Tutoriales.Part2.ILogger, IoC.Tutoriales.Part2">
           <parameters>
               <connectionString>...</connectionString>
           </parameters>
       </component>
    </components>
</configuration>

Introducción.

public class Sumador
{
    public decimal Suma(decimal num1, decimal num2)
    {
        return num1 + num2;
    }
}

...
public static void Main(string[] args)
{
    var sumador = new Sumador();
    var result = sumador.Suma(1,1);
}
...

...
public static WindsorContainer miContenedor;
public static void Main(string[] args)
{
    //Creamos el contenedor
    miContenedor = new WindsorContainer
               (new XmlInterpreter("MiContenedor.xml"));

    //Pedimos un objeto de tipo sumador al contenedor
    var sumador = miContenedor.Resolve<Sumador>();

    var result = sumador.Suma(1,1);
}
...

<configuration>
    <components>
        <component id="Sumador"
            type="IoC.Tutoriales.Part1.Sumador,
                       IoC.Tutoriales.Part1" />
    </components>
</configuration>