ConfORMando Nhibernate 2, Components

Vamos a continuar partiendo del ejemplo de ayer. Teníamos un dominio muy sencillo con  Company y Employee. Si nos fijamos las dos clases tienen la misma estructura para la información de contacto, así que vamos a crear una nueva clase para almacenar estos datos. El dominio queda así:

    public class Company
    {
        virtual public  int CompanyId { get; set; }
        virtual public  string Name { get; set; }
        virtual public ContactInfo ContactInfo { get; set; }
        virtual public  IList Employees { get; set; }
    }
    public class Employee
    {
        virtual public  int EmployeeID { get; set; }
        virtual public  string Name { get; set; }
        virtual public  Company Company { get; set; }
        virtual public ContactInfo ContactInfo { get; set; }
    }
    public class ContactInfo
    {
        virtual public string Address { get; set; }
        virtual public string PostalCode { get; set; }
        virtual public string State { get; set; }
        virtual public string Country { get; set; }
        virtual public string Phone { get; set; }
    }

No nos interesa que ContactInfo tenga una tabla donde se almacene en base de datos, queremos que la información de contacto se siga almacenando en las tablas de empleado y empresa.

Veamos como queda nuestro código con ConfORM y el mapping que genera

            var orm = new ObjectRelationalMapper();          
            orm.Patterns.PoidStrategies.Add(new NativePoidPattern());
            var mapper = new Mapper (orm);

            IEnumerable DomainEntities = typeof(Company).Assembly.GetTypes();
            //A ContactInfo no queremos aplicarle una política de Persistencia por clase, asi que no la incluimos.
            orm.TablePerClass(DomainEntities.Where (e=> e != typeof (ContactInfo)));
            //Le indicamos al Mapper que nos genere el maepo para las TODAS clases del dominio, incluida ContactInfo
            var mapping = mapper.CompileMappingFor(DomainEntities);

<?xml version="1.0" encoding="utf-8"?>
<?XML:NAMESPACE PREFIX = [default] urn:nhibernate-mapping-2.2 NS = "urn:nhibernate-mapping-2.2" />
  
    
      
    
    
    
      
      
      
      
      
    
    
      
      
    
  
  
    
      
    
    
    
    
      
      
      
      
      
    
  

Con component Nhibernate nos permite mapear propiedades de una clase a la tabla de la clase que contiene la tabla. En nuestro caso, las propiedades de ContactInfo se almacenaran en las tablas donde se almacenen las clases que la usen.

En resumen, hemos añadido una clase, pero nuestro modelo de datos no se ha modificado.

ConfORMando NHibernate

Voy a intentar hacer una serie de post explicando como mapear nuestros objetos de dominio a NHibernate utilizando ConfORM.

Lo primero que necesitamos es un dominio. Para este caso vamos a usar un dominio sencillo:

	
    public class Company
    {
        virtual public  int CompanyId { get; set; }
        virtual public  string Name { get; set; }
        virtual public  string Address { get; set; }
        virtual public  string PostalCode { get; set; }
        virtual public  string State { get; set; }
        virtual public  string Country { get; set; }
        virtual public  string Phone { get; set; }
        virtual public  IList Employees { get; set; }
    }
    public class Employee
    {
        virtual public  int EmployeeID { get; set; }
        virtual public  string Name { get; set; }
        virtual public  Company Company { get; set; }
        virtual public  string Address { get; set; }
        virtual public  string PostalCode { get; set; }
        virtual public  string State { get; set; }
        virtual public  string Country { get; set; }
        virtual public  string Phone { get; set; }
    }

Nada que comentar en el dominio. Tenemos una clase empresa que tiene empleados.

Ahora vamos a preparar nuestro ORM, en este caso NHibernate. Voy a utilizar NHibernate 3 y su nueva api de configuración

	    
            Configuration nhConfig = new Configuration();
            nhConfig.SessionFactoryName("ConfORMando");
            nhConfig.Proxy(p =>
                {
                    p.Validation = false;
                    p.ProxyFactoryFactory();
                }
            );
            nhConfig.DataBaseIntegration (db =>
                {
                    db.Dialect();
                    db.Driver();
                    db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;
                    db.IsolationLevel = IsolationLevel.ReadCommitted;
                    db.ConnectionString = connectionString;
                    db.Timeout = 10;
                    db.HqlToSqlSubstitutions = "true 1, false 0, yes 'Y', no 'N'";
                }
            );

Ahora llega el turno de ConfORM. Con este API vamos a usar dos objetos:

• ObjectRelationalMapper: que se utiliza para indicar las reglas generales del mapeo y se le indican las clases que forman parte del dominio


• Mapper: El encargado de generar los metadatos para el ORM concreto, en nuestro caso NHibernate. En este objeto indicaremos (si fuese necesario) las expceiones y correciones manuales de los mapeos.

Para no complicar las cosas en el primer ejemplo (a ver si soy constante y hago más) vamos a dejar las opciones por defecto, salvo el generador de IDs que por defecto utiliza HiLo y por ahora quiero utilizar native.

            
            var orm = new ObjectRelationalMapper();          
            orm.Patterns.PoidStrategies.Add(new NativePoidPattern());
            var mapper = new Mapper (orm);

            IEnumerable DomainEntities = typeof(Company).Assembly.GetTypes();
            //En este ejemplo utilizaremos para las dos clases Table per Class
            orm.TablePerClass(DomainEntities);
            //Le indicamos al Mapper que nos genere el maepo para las clases del dominio
            var mapping = mapper.CompileMappingFor(DomainEntities);

            System.IO.File.WriteAllText (hbmFile, mapping.AsString());
            
            
            //añadimos las clases mapeadas a la configuaracion de Nhibernate que creamos antes
            nhConfig.AddDeserializedMapping(mapping, "ConfORMDomain");

¡¡Ya está ya tenemos nuestras clases mapeadas con NHibernate!! ¿No me creéis? bueno, afortunadamente el Mapper de NHibernate de ConfORM tiene un método llamado AsString con el que se puede generar el fichero hbm. Así que os puedo mostrar el resultado:

<?xml version="1.0" encoding="utf-8"?>
<?XML:NAMESPACE PREFIX = [default] urn:nhibernate-mapping-2.2 NS = "urn:nhibernate-mapping-2.2" />
  
    
      
    
    
    
    
    
    
    
    
      
      
    
  
  
    
      
    
    
    
    
    
    
    
    
  

Y si genero la base de datos utilizando el SchemaExport de NHibernate puedo generar la base de datos (o el script de generación) con este resultado:

Esto es solo la punta del iceberg, ConfORM tiene muchísimo más que ofrecer.

La magia de ConfORM

Como ya comenté el el post anterior ConfORM permite configurar mediante convección el mapeo de las entidades de un dominio a un ORM.

Si a esto le sumamos el uso de NHibernate.Tool.hbm2ddl tendremos una experiencia “Code First” que tan de moda está ahora mismo.

ConfORM examina las clases que le indicamos que forman parte de nuestro dominio y genera la configuración necesaria para el ORM

Fabio Maulo hace que analizar de forma automática las clases de un dominio parezca sencillo. Identifica todo lo que necesita saber y genera un contrato de lo más sencillo para definir un DomainInspector, tal y como explica en este post.

public interface IDomainInspector
{
bool IsRootEntity(Type type);
bool IsComponent(Type type);
bool IsComplex(Type type);
bool IsEntity(Type type);

bool IsTablePerClass(Type type);
bool IsTablePerClassHierarchy(Type type);
bool IsTablePerConcreteClass(Type type);

bool IsOneToOne(Type from, Type to);
bool IsManyToOne(Type from, Type to);
bool IsManyToMany(Type role1, Type role2);
bool IsOneToMany(Type from, Type to);
bool IsHeterogeneousAssociations(MemberInfo member);
Cascade ApplyCascade(Type from, Type to);

bool IsPersistentId(MemberInfo member);
IPersistentIdStrategy GetPersistentIdStrategy(MemberInfo member);

bool IsPersistentProperty(MemberInfo role);
IDbColumnSpecification[] GetPersistentSpecification(MemberInfo role);
}

Fabio explica que una clase por si misma no puede definir como es su persistencia e identifica los casos en los que es necesario un poco de ayuda:

Por un lado están las estrategias de serialización

void TablePerClassHierarchy<TBaseEntity>();
void TablePerClass<TBaseEntity>();
void TablePerConcreteClass<TBaseEntity>();

Por otro lado, algunas relaciones que no se pueden (o no siempre) se pueden detectar automáticamente

void ManyToOne<TLeftEntity, TRigthEntity>();
void OneToOne<TLeftEntity, TRigthEntity>();
void ManyToMany<TLeftEntity, TRigthEntity>();

Y por último si los cambios en entidades desencadenan cambios en la otras (los típicos borrados en cascada, actualizaciones…)

void Cascade<TFromEntity, TToEntity>(Cascade cascadeOptions);

Con todos estos datos introducidos en el DomainInspector, ConfORM puede generar los metadatos necesarios para el ORM puede manejar la persistencia del dominio.

Fuente: http://fabiomaulo.blogspot.com/2010/02/conform-nhibernate-un-mapping.html