If you have liked mapping by code and are excited about being able to declare mappings programmatically, then I am sure you would fall in love with fluent mappings offered by Fluent NHibernate (FNH). As far as I can tell, fluent mapping is the most widely used technique of mapping in NHibernate world and we will see why everyone likes it so much.

FNH scans your code based on mappings, processes them, and comes up with appropriate XML mappings. All this process is transparent to you as developer. But it is useful to remember that all FNH is doing is transforming code-based mappings into XML mappings.

Before we start writing fluent mappings for our classes, let me tell you that FNH, for some reasons, chose to name their APIs differently than their XML or mapping by code counterparts. For example, property mapping in FNH is named Map. This could be a cause of confusion if you are new to FNH but I'm sure your love for FNH would outweigh the confusion and you would soon get used it. Let's get started then.

We will take a slightly different approach to learning fluent mappings. Instead of going through how to map different types of attributes individually, I am going to show you complete mappings for classes in our domain model. We will then look at individual fluent mappings declared for each class. Let's start with Employee:

using Domain;
using FluentNHibernate.Mapping;

namespace Persistence.Mappings.Fluent
{
  public class EmployeeMappings : ClassMap<Employee>
  {
    public EmployeeMappings()
    {
      Id(e => e.Id).GeneratedBy.HiLo("1000");
      Map(e => e.EmployeeNumber);
      Map(e => e.Firstname);
      Map(e => e.Lastname);
      Map(e => e.EmailAddress);
      Map(e => e.DateOfBirth);
      Map(e => e.DateOfJoining);
      Map(e => e.IsAdmin);
      Map(e => e.Password);

      HasOne(e => e.ResidentialAddress).Cascade.All().PropertyRef(a => a.Employee);
      HasMany(e => e.Benefits).Cascade.AllDeleteOrphan();
      HasManyToMany(e => e.Communities)
                         .Table("Employee_Community")
                         .ParentKeyColumn("Employee")
                         .ChildKeyColumn("Community")
                         .Cascade.AllDeleteOrphan();
    }

  }
}

Let's see what is going on here:

Let's look at mapping of the Community class next to see how the other side of many-to-many is mapped. Following is complete fluent mapping for the Community class:

public class CommunityMappings : ClassMap<Community>
{
  public CommunityMappings()
  {
    Id(c => c.Id).GeneratedBy.HiLo("1000");
    Map(c => c.Name);
    Map(c => c.Description);
    HasManyToMany(c => c.Members)
    .Table("Employee_Community")
    .ParentKeyColumn("Community_Id")
    .ChildKeyColumn("Employee_Id")
    .Cascade.AllDeleteOrphan();
  }
}

There is nothing new in here from mappings of the Employee class except a minor detail. ParentKeyColumn is the passed name of foreign key column to the Community table and ChildKeyColumn is the passed name of the foreign key column to the Employee table. This was the other way round in EmployeeMappings for obvious reasons.

Mappings of the Address class are not vastly different as well, again except for mapping of many-to-one Employee association. Let's take a look:

public class AddressMappings : ClassMap<Address>
{
  public AddressMappings()
  {
    Id(a => a.Id).GeneratedBy.HiLo("1000");
    Map(a => a.AddressLine1);
    Map(a => a.AddressLine2);
    Map(a => a.City);
    Map(a => a.Postcode);
    Map(a => a.Country);
    References(a => a.Employee);
  }
}

Again, most of the things are same. Many-to-one association to the Employee class is mapped using the method References. If you ignore the unusual choice of name to represent many-to-one association, the mapping is quite succinct.

We have covered most of the mappings in our domain model, except for inheritance mappings which we would cover next.

public class BenefitMappings : ClassMap<Benefit>
{
  public BenefitMappings()
  {
    Id(b => b.Id).GeneratedBy.HiLo("1000");
    Map(b => b.Name);
    Map(b => b.Description);
    References(b => b.Employee);
  }
}

public class LeaveMappings : SubclassMap<Leave>
{
  public LeaveMappings()
  {
    DiscriminatorValue("LVE");
    Map(l => l.AvailableEntitlement);
    Map(l => l.RemainingEntitlement);
    Map(l => l.Type);
  }
}

public class SeasonTicketLoanMappings : SubclassMap<SeasonTicketLoan>
{
  public SeasonTicketLoanMappings()
  {
    DiscriminatorValue("STL");
    Map(s => s.Amount);
    Map(s => s.MonthlyInstalment);
    Map(s => s.StartDate);
    Map(s => s.EndDate);
  }
}

public class SkillsEnhancementAllowanceMappings :
SubclassMap<SkillsEnhancementAllowance>
{
  public SkillsEnhancementAllowanceMappings()
  {
    DiscriminatorValue("SEA");
    Map(s => s.Entitlement);
    Map(s => s.RemainingEntitlement);
  }
}

public class BenefitMappings : ClassMap<Benefit>
{
  public BenefitMappings()
  {
    Id(b => b.Id).GeneratedBy.HiLo("1000");
    Map(b => b.Name);
    Map(b => b.Description);
    References(b => b.Employee);
    UseUnionSubclassForInheritanceMapping();
  }
}

public class BenefitMappings : ClassMap<Benefit>
{
}

public class LeaveMappings : SubclassMap<Leave>
{
}

public class SeasonTicketLoanMappings : SubclassMap<SeasonTicketLoan>
{
}

public class SkillsEnhancementAllowanceMappings :
SubclassMap<SkillsEnhancementAllowance>
{
}

Component(e => e.ResidentialAddress,
               mapper =>
               {
               mapper.Map(a => a.AddressLine1);
               mapper.Map(a => a.AddressLine2);
               mapper.Map(a => a.City);
               mapper.Map(a => a.Postcode);
               mapper.Map(a => a.Country);
               });