Fluent NHibernate可空的一对一映射

我一直在尝试使用一对一的双向关系映射两个对象。这两个对象之间的关系不是必需的。以下是对象：

public class Tenant
{
    public virtual int TenantId { get; set; }

    public virtual string Name { get; set; }

    public virtual Unit Unit { get; set; }
}

public class Unit
{
    public virtual int UnitId { get; set; }

    public virtual string UnitNumber { get; set; }

    public virtual int Rooms { get; set; }

    public virtual Tenant Tenant { get; set; }
}

下面是我尝试使用的映射：

public class Mappings : ClassMap<Unit>
{

    /*
     * Unit
     * ------------
     * UnitId (PK)
     * TenantId (FK)
     * Rooms
     * UnitNumber
     */

    public Mappings()
    {
        Id(x => x.UnitId).GeneratedBy.Identity();

        References(x => x.Tenant);

        Map(x => x.Rooms).Not.Nullable();
        Map(x => x.UnitNumber).Not.Nullable();
    }
}



public class TenantMapping : ClassMap<Tenant>
{
    /*
     * Tenant
     * -------------
     * TenantId (PK)
     * Name 
     */
    public TenantMapping()
    {
        Id(x => x.TenantId).GeneratedBy.Identity();

        Map(x => x.Name).Not.Nullable();

        HasOne(x => x.Unit).PropertyRef(x => x.Tenant);
    }
}

公共类映射：类映射
{
/*
*单位
* ------------
*统一号（PK）
*承租人（FK）
*房间
*单位数
*/
公共映射（）
{
Id（x=>x.UnitId）.GeneratedBy.Identity（）；
参考文献（x=>x.1）；
Map（x=>x.Rooms）.Not.Nullable（）；
Map（x=>x.UnitNumber）.Not.Nullable（）；
}
}
公共类租户映射：类映射
{
/*
*房客
* -------------
*租户（主键）
*名字
*/
公屋住户地图（）
{
Id（x=>x.TenantId）.GeneratedBy.Identity（）；
Map（x=>x.Name）.Not.Nullable（）；
HasOne（x=>x.Unit）.PropertyRef（x=>x.Tenant）；
}
}

预期的表定义在映射注释中。我用于验证映射的测试失败：

    [Test]
    public void SetTenantOnUnit()
    {
        int unitId = 0;
        int tenantId = 0;
        using (var session = factory.OpenSession())
        {
            var tenants = Builder<Tenant>.CreateListOfSize(5).Build();
            var unit = Builder<Unit>.CreateNew().Build();
            foreach(var tenant in tenants)  
                session.Save(tenant);

            session.Save(unit);

            unit.Tenant = tenants[3];
            tenantId = unit.Tenant.TenantId;
            session.SaveOrUpdate(unit);

            unitId = unit.UnitId;
        }

        using (var session = factory.OpenSession())
        {
            var unit = session.Get<Unit>(unitId);
            Assert.That(unit, Is.Not.Null);
            Assert.That(unit.Tenant, Is.Not.Null);
            Assert.That(unit.Tenant.TenantId, Is.EqualTo(tenantId), "Incorrect Tenant Id");
        }

    }

    [Test]
    public void SetUnitOnTenant()
    {
        int tenantId = 0;
        int unitId = 0;
        using (var session = factory.OpenSession())
        {
            var tenant = Builder<Tenant>.CreateNew().Build();
            var units = Builder<Unit>.CreateListOfSize(5).Build();
            session.Save(tenant);

            foreach(var unit in units)
                session.Save(unit);


            tenant.Unit = units[3];
            unitId = tenant.Unit.UnitId;

            session.SaveOrUpdate(tenant);
            tenantId = tenant.TenantId;
        }

        using (var session = factory.OpenSession())
        {
            var tenant = session.Get<Tenant>(tenantId);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.Unit, Is.Not.Null);
            Assert.That(tenant.Unit.UnitId, Is.EqualTo(unitId), "Incorrect unit id");
        }
    }

[测试]
公共无效设置NantOnUnit（）
{
int unitId=0；
int-tenantId=0；
使用（var session=factory.OpenSession（））
{
var tenants=Builder.CreateListOfSize（5.Build（）；
var unit=Builder.CreateNew（）.Build（）；
foreach（租户中的var租户）
会话.保存（租户）；
会话。保存（单位）；
单位.租户=租户[3]；
tenantId=unit.Tenant.tenantId；
会话.保存或更新（单位）；
unitId=单位。unitId；
}
使用（var session=factory.OpenSession（））
{
var unit=session.Get（unitId）；
Assert.That（单位为.Not.Null）；
Assert.That（unit.Tenant，Is.Not.Null）；
断言（unit.Tenant.TenantId，Is.EqualTo（TenantId），“不正确的租户Id”）；
}
}
[测试]
public void SetUnitOnTenant（）
{
int-tenantId=0；
int unitId=0；
使用（var session=factory.OpenSession（））
{
var tenant=Builder.CreateNew（）.Build（）；
var units=Builder.CreateListOfSize（5.Build（）；
会话.保存（租户）；
foreach（单位为var单位）
会话。保存（单位）；
租户。单位=单位[3]；
unitId=租户.Unit.unitId；
会话。保存或更新（租户）；
tenantId=tenant.tenantId；
}
使用（var session=factory.OpenSession（））
{
var tenant=session.Get（tenantId）；
Assert.That（租户，Is.Not.Null）；
Assert.That（tenant.Unit，Is.Not.Null）；
断言（tenant.Unit.UnitId，Is.EqualTo（UnitId），“不正确的单元id”）；
}
}

我在这里包含了源代码：

---

理想情况下，我能够从任意一方创建关系，并将其成功保存到数据库中。我已经阅读了关于StackOverFlow的其他一对一映射主题，但没有一个主题是直接针对这一点的。如何正确映射此关系？

您缺少一个

会话。Flush（）在
unitId=unit.unitId之后和
tenantId=tenant.tenantId因此分配不保存在db中。保存租户和单元的原因是您强制NHibernate在
session.Save（）
上立即插入。由于您设置了
GeneratedBy.Identity（）
nhibernate必须向数据库请求id，否则
unitId=unit.unitId将产生错误的结果