A finales del agosto, James Gregory anunció la publicación de la versión 1.0 de Fluent NHibernate, una librería que ofrece una ágil alternativa a los espesos archivos de configuración de NHibernate.
Su API permite configurar desde el código de una aplicación, de forma fluida la mayoría de las veces, los mapeos entre la estructura de una base de datos relacional y el modelo de objetos que utiliza. Así, evitaremos la manipulación de grandes archivos XML, a la vez que podremos beneficiarnos de la validación en tiempo de compilación y, por supuesto, de posibilidades como la refactorización y el intellisense durante el desarrollo.
El siguiente código muestra el mapeo de la entidad Cat
con sus propiedades, algunas de ellas con restricciones, y relaciones con otras entidades a uno (References
) y a varios (HasMany
); el nombre de la tabla y campos en el modelo relacional es el mismo que el de las propiedades, gracias a la convención sobre configuración, lo que permite simplificar código respecto a su equivalente XML:
public class CatMap : ClassMap<Cat>
{
public CatMap()
{
Id(x => x.Id);
Map(x => x.Name)
.Length(16)
.Not.Nullable();
Map(x => x.Sex);
References(x => x.Mate);
HasMany(x => x.Kittens);
}
}
Como podemos observar, el equivalente XML es mucho más verboso:
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
namespace="QuickStart" assembly="QuickStart">
<class name="Cat" table="Cat">
<id name="Id">
<generator class="identity" />
</id>
<property name="Name">
<column name="Name" length="16" not-null="true" />
</property>
<property name="Sex" />
<many-to-one name="Mate" />
<bag name="Kittens">
<key column="mother_id" />
<one-to-many class="Cat" />
</bag>
</class>
</hibernate-mapping>
Otra de las ventajas que aporta es el auto-mapping, que hace utilización intensiva del principio de convención sobre configuración para generar de forma automática mapeos de aquellas entidades que atiendan a unas normas preestablecidas (aunque modificables). El siguiente código muestra la forma tan sencilla de crear los mapeos de todas las entidades definidas en el espacio de nombres MiApp.Entidades
, dentro del ensamblado donde se definió la entidad Producto
:
var autoMappings = AutoMap.AssemblyOf<Producto>()
.Where(t => t.Namespace == "MiApp.Entidades");
Además del mapeo objeto-relacional, el software abarca también la configuración del acceso a datos de NHibernate a través de su interfaz de programación. El siguiente código muestra la inicialización de la conexión a una base de datos SQL Server 2005, tomando la cadena de conexión del
AppSettings
y mapeando automáticamente las entidades que se encuentren definidas en un namespace concreto:var sessionFactory = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2005
.ConnectionString(c => c.FromAppSetting("connectionString"))
.Mappings(m => m.AutoMappings.Add(
AutoMap.AssemblyOf<Producto>(type => type.Namspace.EndsWith("Entidades"))))
.BuildSessionFactory();
Y por último, hay otra característica muy interesante vistas a la realización de pruebas unitarias sobre los mecanismos de persistencia. El código mostrado a continuación crea una instancia de la clase Empleado
, la inserta en la base de datos, realiza una lectura de la entidad y la compara con la original, de forma automática:
[Test]
public void EmpleadoMapeaCorrectamente()
{
new PersistenceSpecification<Empleado>(session)
.CheckProperty(emp => emp.Id, 1)
.CheckProperty(emp => emp.Nombre, "José")
.CheckProperty(emp => emp.Apellidos, "Aguilar")
.VerifyTheMappings();
}
Más información en la wiki del proyecto. Y las descargas, desde aquí.
Publicado en: Variable not found.
Publicado por José M. Aguilar a las 1:12 a. m.
Etiquetas: .net, bases de datos, desarrollo, interfaces fluidos, novedades, orm, software libre
Hace unas semanas, Oren Eini (o Ayende Raihen, como se le suele conocer) comunicaba la liberación de la versión 1.0 del proveedor de Linq para NHibernate, una característica altamente demandada por los usuarios desde la aparición del lenguaje de consulta integrado en .NET.
Aunque será incluido como parte del producto NHibernate en versiones venideras, han decidido liberar la actual release del proveedor como paquete independiente para que pueda comenzar a utilizarse desde este momento. Está siendo testado en multitud de aplicaciones en producción desde hace varios años, y al parecer el funcionamiento es más que correcto.
¿Y cómo puede ayudarte este proveedor, si eres usuario de NHibernate? El siguiente ejemplo, tomado de Caffeinated Coder muestra cómo una consulta a base de datos puede simplificarse y hacerse mucho más legible utilizando Linq, además de beneficiarse del tipado fuerte, intellisense y comprobaciones en tiempo de compilación:
Utilizando el API de NHibernate:
public IList<Call> GetCallsByDate(DateTime beginDate, int interpreterId)
{
ICriteria criteria = Session.CreateCriteria(typeof(Call))
.CreateAlias("Customer", "Customer")
.Add(Restrictions.Gt("StartTime", beginDate))
.Add(
Restrictions.Or(
Restrictions.Lt("EndTime", DateTime.Now), Restrictions.IsNull("EndTime"))
)
.Add(Restrictions.Eq("Interpreter.Id", interpreterId))
.AddOrder(Order.Desc("StartTime"))
.AddOrder(Order.Desc("Customer.Name"));
return criteria.List<Call>() as List<Call>;
}
Utilizando Linq:
public IList<Call> GetCallsByDateWithLinq(DateTime beginDate, int interpreterId)
{
var query = from call in Session.Linq<Call>()
where call.StartTime > beginDate
&& (call.EndTime == null || call.EndTime < DateTime.Now )
&& call.Interpreter.Id == interpreterId
orderby call.StartTime descending, call.Customer.Name
select call;
return query.ToList();
}
Podéis descargar tanto los binarios como el código fuente desde la página del proyecto en SourceForge.
Publicado en: Variable not found.
Publicado por José M. Aguilar a las 9:18 p. m.
Etiquetas: .net, bases de datos, desarrollo, linq, novedades, orm