So today I updated to the latest build of Fluent NHibernate. As any of you who might have done the same have discovered there are some breaking changes. I wasn’t sure I liked the new class based conventions at first, especially since it wasn’t clear at first how to tackle altering my mappings. Then it dawned on me how powerful the conventions would end up being while also promoting DRY.
as @jagregory said :
“brevity was sacrificed for power in this case.”
This can be seen in the example below which is a self referencing Parent Child relationship.
The description of the relationship is:
Categories can have one or none parents.
Categories can have many or no children.
The parent Category is always found in a property called “Parent”.
The children are always found in a property called “Children”.
Before
Original Mapping:
public class CategoryMap : ClassMap<Category>
{
public CategoryMap()
{
Id(x => x.Id);
Map(x => x.Name);
References(x => x.Parent).TheColumnIs("parent_id").Cascade.All();
HasManyToMany(x => x.Products).Inverse();
HasMany(x => x.Children).WithKeyColumn("parent_id").Cascade.All().Inverse();
}
}
**Note: These aren’t exactly “Conventions” but it turned out that ‘WithKeyColumn’ got dropped and I had to look for a better way. The new style conventions offered that even over older convention styles.
After
The new style Convention Mappings :
The Convention classes below create a convention that reads like:
“For a HasMany when the child type matches the type of the root and the name of the property is ‘Children’ then use the column ‘parent_id’ as the KeyColumn. For a Reference when the child type matches the type of the root and the name of the property is ‘Parent’ then set its reference ColumnName to ‘parent_id’ “
public class SelfReferencingHasManyConvention : IHasManyConvention
{
public bool Accept(IOneToManyPart target)
{
return target.Member.ReflectedType == target.EntityType && target.Member.Name == "Children";
}
public void Apply(IOneToManyPart target)
{
target.KeyColumnNames.Clear();
target.KeyColumnNames.Add("parent_id");
}
}
public class SelfReferencingReferenceConvention : IReferenceConvention
{
public bool Accept(IManyToOnePart target)
{
return target.Property.ReflectedType == target.EntityType && target.Property.Name == "Parent";
}
public void Apply(IManyToOnePart target)
{
target.ColumnName("parent_id");
}
}
The Mapping after the convention :
Clean and clear, the conventions themselves are not cluttering the Mapping. More importantly the conventions help me stay DRY.
public class CategoryMap : ClassMap<Category>
{
public CategoryMap()
{
Id(x => x.Id);
Map(x => x.Name);
References(x => x.Parent).Cascade.All();
HasManyToMany(x => x.Products).Inverse();
HasMany(x => x.Children).Cascade.All().Inverse();
}
}
Adding Mappings to my Persistence Model
You can see that adding the conventions was pretty easy and straight forward. This applies to the fact that I am using the PersistenceModel approach.
public class DataModel : PersistenceModel
{
public DataModel()
{
AddMapping(new ProductMap());
AddMapping(new CategoryMap());
ConventionFinder.AddFromAssemblyOf<DataModel>();
}
}
