In NHibernate parlance, bidirectional associations have a notion of ownership. Ownership defines how the foreign key that underpins the bidirectional association is updated when new items are added to an association in memory. You can declare any end of the association to be the owner. Your choice of ownership affects the SQL that is generated in order to synchronize the association correctly to database. Let's elaborate this with an example.

Following diagram depicts the bidirectional relationship between the Employee and Benefit class:

The Employee to Benefit association is a bidirectional association which can also be seen as parent-child relation. Employee acts as parent and has multiple child benefits associated to it. From purely technical point of view, this is a one-to-many association. In one-to-many association, if ownership is not defined, then "one" side is considered as owner by default. So in our example, employee is owner of the association. What that tells NHibernate is that employee is responsible for setting this association up in the database correctly. So, for every benefit record that gets inserted into the database, employee would make sure that foreign key column Employee_Id on the Benefit table is updated with its own id. This is clear from the SQL that is generated by the following piece of code:

using (var tx = Session.BeginTransaction())
{
  var employee = new Employee();
  employee.AddBenefit(new SeasonTicketLoan
  {
    Amount = 1200,
    MonthlyInstalment = 100,
    StartDate = new DateTime(2014, 5, 12),
    EndDate = new DateTime(2015, 4, 12)
  });
  id = Session.Save(employee);

  tx.Commit();
}

The preceding code sends the following SQL to the database (stripped down to essential part for brevity):

If you remember, we have seen this example earlier when we talked about setting both ends of bidirectional association. As we had noted back then, after inserting the Employee and Benefit record, an additional update statement is issued to update the Employee_Id column on the Benefit table. Think of it like this - because employee is responsible for making sure that foreign key column is updated correctly, employee would issue an additional update statement for every benefit item in its Benefits collection. This additional update is actually unnecessary and at times may impact performance. If we turn the tables around and make the Benefit entity the owner of the association, then this extra update statement goes away. So how do you make Benefit the owner of association? This is where the Inverse property of one-to-many association mapping comes in. Inverse is a Boolean property that you can declare on the one-to-many mapping, as shown next:

Set(e => e.Benefits,mapper =>
{
  mapper.Key(k => k.Column("Employee_Id"));
  mapper.Cascade(Cascade.All.Include(Cascade.DeleteOrphans));
  mapper.Inverse(true);
},
relation => relation.OneToMany(mapping => mapping.Class(typeof(Benefit))));

The preceding code listing is part of employee mapping. Note the code in bold where Inverse is set to true. This is telling NHibernate that other end of this association (Benefit in this case) is owner of the association and should be responsible for updating the foreign key in the database. After this change, if we run the preceding code again, we would notice that the extraneous update statement is no more generated.

So to summarize – in one-to-many association, if "one" side is declared as owner then you get an unnecessary update statement during insertion of new records. On the other hand, if "many" side is made the owner, the unnecessary update statement is not generated.