Gestern Abend habe ich mich mal wieder ein wenig mit Fluent NHibernate beschäftigt. Mein Ziel war es, eine Objektstruktur, die aus einer Basisklasse und zwei abgeleiteten Klassen besteht mittels Fluent NHibernate zu speichern.
Nach einigem Fehlversuchen bin ich dann zu folgendem Ergebnis gekommen:
public class KontaktMap : ClassMap<Kontakt>
{
public KontaktMap()
{
Id(x => x.KontaktId)
.GeneratedBy
.GuidComb()
.WithUnsavedValue("00000000-0000-0000-0000-000000000000");
Map(x => x.KontaktPerson);
JoinedSubClass<Brief>("KontaktId", MapBrief);
JoinedSubClass<Anruf>("KontaktId", MapAnruf);
}
private static void MapBrief(JoinedSubClassPart<Brief> part)
{
part.Map(x => x.Absender);
part.Map(x => x.Text);
}
private static void MapAnruf(JoinedSubClassPart<Anruf> part)
{
part.Map(x => x.Telefonnummer);
part.Map(x => x.Bemerkung);
}
}Hier das vollständige Beispiel: Download
Habt ihr Euch auch schon einmal darüber geärgert, wieder diese unschönen XML-Dateien für das Mapping von NHibernate schreiben zu müssen? Seit kurzem gibt es gegen diese Unschönheit eine Lösung. Fluent NHibernate bietet Euch die Möglichkeit Eure Mappings “strongly typed” zu definieren. Anstatt der hbm.xml-Datei gibt es mit Fluent NHibernate eine Mapping-Klasse.
Die Klasse Person mit einer Liste von Adressen
public class Person
{
public virtual Guid PersonId { get; set; }
public virtual string Vorname { get; set; }
public virtual string Nachname { get; set; }
public virtual IList<Adresse> Adressen { get; set; }
}kann dann wie folgt gemappt werden.
public class PersonMap : ClassMap<Person>
{
public PersonMap()
{
Id(x => x.PersonId)
.GeneratedBy
.GuidComb()
.WithUnsavedValue("00000000-0000-0000-0000-000000000000");
Map(x => x.Vorname).WithLengthOf(50);
Map(x => x.Nachname).WithLengthOf(50);
HasMany<Adresse>(x => x.Adressen)
.Access.AsProperty()
.AsBag().WithKeyColumn("PersonId")
.Cascade.All();
}
}Aber welche Vorteile biete die Fluent-Variante?
1. Die XML-Mapping-Dateien können nicht vom Compiler geprüft werden. Fehlkonfigurationen fallen erst zu Laufzeit auf (Exception)
2. Mapping-Klassen werden wie alle anderen Klassen vom Compiler geprüft. Fehler fallen zu Entwurfszeit auf.
3. Beim Umbennen von Feldern in Klassen über die Refactoring-Möglichkeiten von Visual Studio bzw. Erweiterungen werden die Felder in den Mapping-Klassen ebenfalls umbenannt. Bei den XML-Mappings müsste das händisch gemacht werden.
4. Fluent-Mappings sind deutlich kürzer bzw. deutlich besser lesbar.
Auch die Konfiguration von NHibernate kann über eine FluentVariante realisiert werden.
ISessionFactory sessionFactory = Fluently
.Configure()
.Database(SQLiteConfiguration.Standard.UsingFile("Beispiel.db"))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Person>())
.BuildSessionFactory();Unter http://fluentnhibernate.org/ kann man sich die aktuelle Version der NHibernate-Erweitung laden und mit der neuen XML-freien Variante von Mappings anfreunden.
Das komplette Beispiel gibt es hier.
