C# 流利的NHibernate一对多，3门课程

我有3个类及其映射，每个类都引用了前面的类：

A->B->C

A可以有C，但前提是B得到C（因为A->C是不可能的）

A类
{
公共虚拟整数Id{get；set；}
公共虚拟字符串messageA{get；set；}
公共虚拟IList Bs{get；set；}
}
B类
{
公共虚拟整数Id{get；set；}
公共虚拟字符串messageB{get；set；}
公共虚拟A{get；set；}
公共虚拟IList Cs{get；set；}
}
C类
{
公共虚拟整数Id{get；set；}
公共虚拟字符串messageC{get；set；}
公共虚拟B{get；set；}
}
//映射
类AMap：类映射
{
公共AMap（）
{
Id（x=>x.Id）；
Map（x=>x.a）；
HasMany（x=>x.Bs）；
}   
}
类BMap:ClassMap
{
公共BMap（）
{
Id（x=>x.Id）；
Map（x=>x.messageB）；
引用（x=>x.A）.Cascade.All（）；
HasMany（x=>x.Cs）；
}   
}
类CMap:ClassMap
{
公共CMap（）
{
Id（x=>x.Id）；
Map（x=>x.messageC）；
引用（x=>x.B）.Cascade.All（）；
}   
}

我在尝试提交时出错：

对象引用未保存的临时实例-保存临时实例 实例，或将属性的级联操作设置为 可以让它自动保存的东西。类型：NHibernateTest.C，实体： NHibernateTest.C

我在寻找解决方案，有人说我必须将外键更新规则修改为级联，我这样做了，但仍然没有工作

---

我只想指出，当我添加C时，它正在使用A->B关系。为了避免将来出现此类问题，您应该确保：

• 你所有的课都是公开的
• 不要像示例B->A、C->B那样使用循环引用

---

下面的测试用例按照您的预期工作（A->B->C）

模型定义：

public class A
{
    public virtual int Id { get; set; }
    public virtual string messageA { get; set; }
    public virtual IList<B> Bs { get; set; }
}


public class B
{
    public virtual int Id { get; set; }
    public virtual string messageB { get; set; }
    public virtual IList<C> Cs { get; set; }
}

public class C
{
    public virtual int Id { get; set; }
    public virtual string messageC { get; set; }
}

public class AMap : ClassMap<A>
{
    public AMap()
    {
        Table("A");
        Id(x => x.Id).Column("Id");
        Map(x => x.messageA);
        HasMany(x => x.Bs).Cascade.All();
    }
}

public class BMap : ClassMap<B>
{
    public BMap()
    {
        Table("B");
        Id(x => x.Id).Column("Id"); ;
        Map(x => x.messageB);
        HasMany(x => x.Cs).Cascade.All();
    }
}

public class CMap : ClassMap<C>
{
    public CMap()
    {
        Table("C");
        Id(x => x.Id).Column("Id"); ;
        Map(x => x.messageC);
    }
}

[Test]
public void ShouldCorrectlyMapA()
{
    var objectA = new A
    {
        Id = 1,
        messageA = "Message A",
        Bs = new List<B> { 
            new B
            {
                messageB = "Message B",
                Cs = new List<C>
                {
                    new C
                    {
                        messageC = "Message C"
                    }
                }
            }
        }
    };

    new PersistenceSpecification<A>(_session)
        .VerifyTheMappings(objectA);

}

对刚创建的架构的操作：

public class A
{
    public virtual int Id { get; set; }
    public virtual string messageA { get; set; }
    public virtual IList<B> Bs { get; set; }
}


public class B
{
    public virtual int Id { get; set; }
    public virtual string messageB { get; set; }
    public virtual IList<C> Cs { get; set; }
}

public class C
{
    public virtual int Id { get; set; }
    public virtual string messageC { get; set; }
}

public class AMap : ClassMap<A>
{
    public AMap()
    {
        Table("A");
        Id(x => x.Id).Column("Id");
        Map(x => x.messageA);
        HasMany(x => x.Bs).Cascade.All();
    }
}

public class BMap : ClassMap<B>
{
    public BMap()
    {
        Table("B");
        Id(x => x.Id).Column("Id"); ;
        Map(x => x.messageB);
        HasMany(x => x.Cs).Cascade.All();
    }
}

public class CMap : ClassMap<C>
{
    public CMap()
    {
        Table("C");
        Id(x => x.Id).Column("Id"); ;
        Map(x => x.messageC);
    }
}

[Test]
public void ShouldCorrectlyMapA()
{
    var objectA = new A
    {
        Id = 1,
        messageA = "Message A",
        Bs = new List<B> { 
            new B
            {
                messageB = "Message B",
                Cs = new List<C>
                {
                    new C
                    {
                        messageC = "Message C"
                    }
                }
            }
        }
    };

    new PersistenceSpecification<A>(_session)
        .VerifyTheMappings(objectA);

}