Reference Fluent NHibernate引用/多对一映射级联全部不工作

我对cascade all（孤立）和从数据库中删除旧的objset有一些问题

例如： 我有一个类A，其中包含一个类B的对象。现在，当我创建一个类A的对象并保存它时，一切正常。当我调用方法

SetValueOfB（inti）

并再次保存对象A时，旧对象B仍在数据库中

类之间的关联必须始终是定向的（对于每个HasMany/Reference/HasOne…）？（但对象b对对象a一无所知）

有没有办法解决单向关联的问题

我需要一对一的映射吗？因为对象B只能属于对象A（A是参数，B是值）

下面是一个失败的测试：

using System.Collections.Generic;
using System.Data;
using System.IO;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using FluentNHibernate.Mapping;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;
using NUnit.Framework;

namespace ReferenceCascade.Test
{
public class CascadeTest
{
    private const string DbFile = "firstProject.db";

    [Test]
    public void checkCascadeAll()
    {
        var sessionFactory = CreateSessionFactory();

        A testee = new A(new B(1));

        using (var session = sessionFactory.OpenSession())
        {
            using (var transaction = session.BeginTransaction())
            {

                session.SaveOrUpdate(testee);

                transaction.Commit();
            }
        }

        testee.SetValueOfB(2);

        using (var session = sessionFactory.OpenSession())
        {
            using (var transaction = session.BeginTransaction())
            {
                session.SaveOrUpdate(testee);

                transaction.Commit();
            }
        }

        using (var session = sessionFactory.OpenSession())
        {
            using (session.BeginTransaction())
            {
                IList<B> stores = session.CreateCriteria(typeof(B))
                  .List<B>();

                Assert.That(stores.Count, Is.EqualTo(1));
            }
        }
    }

    private static ISessionFactory CreateSessionFactory()
    {
        return Fluently.Configure()
          .Database(SQLiteConfiguration.Standard.UsingFile(DbFile).IsolationLevel(IsolationLevel.ReadCommitted))
          .Mappings(m =>
            m.FluentMappings.AddFromAssemblyOf<CascadeTest>())
          .ExposeConfiguration(BuildSchema)
          .BuildSessionFactory();
    }

    private static void BuildSchema(Configuration config)
    {
        // delete the existing db on each run
        if (File.Exists(DbFile))
        {
            File.Delete(DbFile);
        }

        // this NHibernate tool takes a configuration (with mapping info in)
        // and exports a database schema from it
        new SchemaExport(config)
          .Create(false, true);
    }
}

public abstract class Entity
{
    public const long InitialId = 0;

    private readonly long _id;

    protected Entity()
    {
        _id = InitialId;
    }

    public virtual long Id
    {
        get { return _id; }
    }
}

public class A : Entity
{
    private B _b;

    public A()
    {
    }

    public A(B b)
    {
        _b = b;
    }

    public virtual void SetValueOfB(int i)
    {
        _b = new B(i);
    }

    public virtual B B
    {
        get { return _b; }
    }
}

public class B : Entity
{
    private readonly int _i;

    public B()
    {
    }

    public B(int i)
    {
        _i = i;
    }

    public virtual int I
    {
        get { return _i; }
    }
}

public class EntityMap<T> : ClassMap<T> where T : Entity
{
    public EntityMap()
    {
        Id(x => x.Id).GeneratedBy.HiLo("33878").Access.CamelCaseField(Prefix.Underscore);
    }
}

public class AMap : EntityMap<A>
{
    public AMap()
    {
        Table("A");
        References(x => x.B).Not.LazyLoad().Cascade.All().Access.CamelCaseField(Prefix.Underscore);
    }
}

public class BMap : EntityMap<B>
{
    public BMap()
    {
        Table("B");
        Map(x => x.I).Not.LazyLoad().Access.CamelCaseField(Prefix.Underscore);
    }
}

使用System.Collections.Generic；
使用系统数据；
使用System.IO；
使用FluentNHibernate.Cfg；
使用FluentNHibernate.Cfg.Db；
使用FluentNHibernate.Mapping；
使用NHibernate；
使用NHibernate.Cfg；
使用NHibernate.Tool.hbm2ddl；
使用NUnit.Framework；
命名空间ReferenceCascade.Test
{
公共类级联测试
{
私有常量字符串DbFile=“firstProject.db”；
[测试]
public void checkCascadeAll（）
{
var sessionFactory=CreateSessionFactory（）；
A受试者=新的A（新的B（1））；
使用（var session=sessionFactory.OpenSession（））
{
使用（var transaction=session.BeginTransaction（））
{
会话。保存或更新（受试者）；
Commit（）；
}
}
受试者设定值B（2）；
使用（var session=sessionFactory.OpenSession（））
{
使用（var transaction=session.BeginTransaction（））
{
会话。保存或更新（受试者）；
Commit（）；
}
}
使用（var session=sessionFactory.OpenSession（））
{
使用（session.BeginTransaction（））
{
IList stores=session.CreateCriteria（类型（B））
.List（）；
Assert.That（stores.Count，Is.EqualTo（1））；
}
}
}
私有静态ISessionFactory CreateSessionFactory（）
{
流畅地返回。Configure（）
.Database（SQLiteConfiguration.Standard.UsingFile（DbFile）.IsolationLevel（IsolationLevel.ReadCommitted））
.Mappings（m=>
m、 FluentMappings.AddFromAssemblyOf（））
.ExposeConfiguration（构建架构）
.BuildSessionFactory（）；
}
私有静态void BuildSchema（配置）
{
//在每次运行时删除现有数据库
if（File.Exists（DbFile））
{
Delete（DbFile）；
}
//此NHibernate工具采用配置（映射信息位于）
//并从中导出数据库架构
新SchemaExport（配置）
.创建（假、真）；
}
}
公共抽象类实体
{
public const long InitialId=0；
私有只读长id；
受保护实体（）
{
_id=初始id；
}
公共虚拟长Id
{
获取{return\u id；}
}
}
公共A类：实体
{
私人B_B ;；
公共A（）
{
}
公共服务A（B）
{
_b=b；
}
公共虚拟无效SetValueOfB（int i）
{
_b=新的b（i）；
}
公共虚拟B
{
获取{return\u b；}
}
}
公共B类：实体
{
私有只读int_i；
公共图书馆B（）
{
}
公共B（内部i）
{
_i=i；
}
公共虚拟国际
{
获取{return\u i；}
}
}
公共类EntityMap:ClassMap，其中T:Entity
{
公共实体映射（）
{
Id（x=>x.Id）.GeneratedBy.HiLo（“33878”）.Access.CamelCaseField（前缀.下划线）；
}
}
公共类AMap:EntityMap
我们还没有找到解决问题的方法。在NHibernate版本4.1中，问题将得到解决，可以使用cascade=all delete orphan多对一。请参见此处：
我们还没有找到解决问题的方法。在NHibernate版本4.1中，问题将得到解决，并且可以使用cascade=all delete orphan with many to one。请参见此处：
如果B与A绑定，为什么将其放在单独的表中？legacy？
cascade。这里需要delete orphan，但这仅适用于子集合，因为它对引用没有意义。如果B与A绑定，为什么将其放在单独的表中？legacy？
cascade.DeleteOrphan
是您在此处需要的，但这仅适用于子项集合，因为它对于引用没有意义。