NHibernate, Bidirectional vs Unidirectional associations

I heard from some peoples that bidirectional association is evil. I don’t know where them sneezed it from. I am not going to take a side and discuss it here. I am going to tell you that your choice have influence on NHibernate behavior and your code’s performance.
Lets start with bidirectional association.

public class Order{
    public virtual Guid Id { get; set; }
    public virtual int Version { get; set; }
    public virtual DateTime OrderTime { get; set; }
    public virtual ICollection<OrderLine> OrderLines { get; set; }
}

public class OrderLine{
    public virtual Guid Id { get; set; }
    public virtual Order Order { get; set; }
    public virtual string ProductName { get; set; }
    public virtual decimal Price { get; set; }
    public virtual int Quantity { get; set; }
}

Order references a collection of order lines and each order line references it’s order. And I map collection as <bag> with inverse=true option.
Lets try to add a new order line to an existing order.

using (var session = sessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
    var order = session.Get<Order>(id);
    order.OrderLines.Add(new OrderLine
    {
        Order = order,
        ProductName = "Product 1",
        Price = 9.99M,
        Quantity = 15
    });

    tx.Commit();
}

Take a look on what is going in the database

SELECT 
    order0_.Id as Id0_0_, 
    order0_.Version as Version0_0_, 
    order0_.OrderTime as OrderTime0_0_ 
FROM Orders order0_ 
WHERE order0_.Id=@p0

INSERT INTO OrderLines (OrderId, ProductName, Price, Quantity, Id) 
VALUES (@p0, @p1, @p2, @p3, @p4)

UPDATE Orders SET Version = @p0, OrderTime = @p1 WHERE Id = @p2 AND Version = @p3

Works as expected. The last query is for aggregate root versioning.
Now lets see what happens when we use model with unidirectional association. Little changes to code and mapping. And that’s what we got in the database.

SELECT 
    order2x0_.Id as Id0_0_, 
    order2x0_.Version as Version0_0_, 
    order2x0_.OrderTime as OrderTime0_0_ 
FROM Orders order2x0_ 
WHERE order2x0_.Id=@p0

SELECT 
    orderlines0_.OrderId as OrderId1_, 
    orderlines0_.Id as Id1_, 
    orderlines0_.Id as Id1_0_, 
    orderlines0_.ProductName as ProductN2_1_0_, 
    orderlines0_.Price as Price1_0_, 
    orderlines0_.Quantity as Quantity1_0_ 
FROM OrderLines orderlines0_ 
WHERE orderlines0_.OrderId=@p0

INSERT INTO OrderLines (ProductName, Price, Quantity, Id) 
VALUES (@p0, @p1, @p2, @p3)

UPDATE Orders SET Version = @p0, OrderTime = @p1 WHERE Id = @p2 AND Version = @p3

UPDATE OrderLines SET OrderId = @p0 WHERE Id = @p1

Dah!? What’s going on here?
The second query ignoring that collection mapped as a bag and goes to bring us already existing order lines. Seems like a bug.
Third query forgot to set reference from the new order line to the order.
And fifth query fixes that mistake. And that update will be executed for each order line.
It’s annoying. So, finally, we have at least two unnecessary queries when we decide to use unidirectional association.
I don’t know why and what was going in the heads of NH programmers when them coded it (no offence), but that is what we have and we will use it for the win! Just know your tools and make right decisions.