One-to-one mapping behaviour change with Version 5.4.0

[fhaemmerli]

We wanted to Update to Nhibernate 5.4.0 but realized that the behaviour changed when updating parent/child relations on one-to-one mappings.

Until Nhibernate 5.3.14 the version property of the parent did not change when adding a child.
This has now changed, as Nhibernate updates also the Parent when adding a child.

When debugging Nhibernate 5.3.14 there were two EntityInsertActions one for the Parent and one for the child. Now with 5.4 there are three, two EntityInsertActions for the parent and child and one EntityUpdateActions for the parent.

Maybe i can illustrate our finding with a test:

We have two Entitys, HasOneParent & HasOneChild

public class HasOneParent : EntityBase
{
	public virtual string Data { get; set; }

	public virtual HasOneChild Child { get; set; }
}

public class HasOneChild : EntityBase
{
    private HasOneParent parent;

    public virtual HasOneParent Parent
    {
        get => this.parent;

        set
        {
            if (value != null)
            {
                value.Child = this;
            }
            else
            {
                if (this.parent != null)
                {
                    this.parent.Child = null;
                }
            }

            this.parent = value;
        }
    }

    public virtual string Data { get; set; }
}

For these two we have the following mapping (Using FluentNhibernate)

public class HasOneParentMap : AbstractEntityMap<HasOneParent>
{
    public HasOneParentMap()
    {
        this.HasOne(x => x.Child)
            .PropertyRef(x => x.Parent)
            .Cascade.All();

        this.Map(x => x.Data)
            .Nullable()
            .Length(100);
    }
}

public class HasOneChildMap : AbstractEntityMap<HasOneChild>
{
    public HasOneChildMap()
    {
        this.References(x => x.Parent)
            .Unique()
            .Nullable();

        this.Map(x => x.Data)
            .Nullable()
            .Length(100);
    }
}

And the mapping for the version and Id

public abstract class AbstractEntityMap<TEntity> : ClassMap<TEntity>
where TEntity : EntityBase
{
    protected AbstractEntityMap()
    {
        this.Initialize();
    }

    private void Initialize()
    {
        this.OptimisticLock.Version();

        this.Id(x => x.Id)
            .GeneratedBy.GuidComb();

        this.Version(x => x.Version)
            .Not.Nullable()
            .UnsavedValue("0");
    }
}

Now in our test we want to create HasOneParent in a session, then in a second session we want to add a child.
This works but it also increments the version of the parent to 2 instead of keeping it on 1.

public void WhenAddingChildToParent_MustNotIncrementVersionOfParent()
{
   Guid parentId = this.InTransaction(session =>
   {
       var parent = new HasOneParent();
       session.Save(parent);
       return parent.Id;
   });

   this.InTransaction(session =>
   {
       var parent = session.Load<HasOneParent>(parentId);
       var child = new HasOneChild { Parent = parent };
       session.Save(child);
   });

   this.InTransaction(session => session.Load<HasOneParent>(parentId).Child)
       .Should().NotBeNull();

   this.InTransaction(session => session.Load<HasOneParent>(parentId).Version)
       .Should().Be(1);
}

This behaviour can be rectified if we use a method on the parent to update the relation, instead of directly accessing the property like:

public class HasOneParent : EntityBase
{
    private HasOneChild child; 

    public virtual string Data { get; set; } 

    public virtual HasOneChild Child 
    { 
        get => this.child; 
        set => this.child = value; 
    } 

    public void SetChild(HasOneChild child) 
    { 
        this.child = child; 
    }
}

Now the question is if our implementation is wrong and we should use a method for the update action, or if something changed in the new Nhibernate version.

[bahusoid]

Behavior is changed by implementing proper caching for one-to-one association #2576

In 5.4.1+ restore old behavior by setting optimistic-lock="false" for one-to-one mapping (.Not.OptimisticLock() in Fluent NHibernate):

  public HasOneParentMap()
  {
      this.HasOne(x => x.Child)
          .PropertyRef(x => x.Parent)
          .Not.OptimisticLock() //<-- added code
          .Cascade.All();

From one-to-one xml mapping doc:

optimistic-lock (optional - defaults to true): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, determines if a version increment should occur when this property is dirty.

[fhaemmerli]

I tried it but it did not work either.

We now opted to use a backing field. This worked for us.

Thanks for your help

[fredericDelaporte]

#3216 will fix this.