S#arp Architecture Repository.DbContext.CommitTransaction() 异常行为

Question

我面临存储库和事务的异常行为 这让我很生气。

我有两个简单的 POCO 类 Action 和 Version ，如下所示。有 动作->版本之间的一对多关系。

public class Action : Entity
{
    public virtual string Name
    {
        get;
        set;
    }

    public virtual IList<Version> Versions
    {
        get;
        protected set;
    }

    public Action()
    {
        Versions = new List<Version>();
    }

    public virtual void AddVersion( Version version )
    {
        version.Action = this;
        Versions.Add( version );
    }
}

public class Version : Entity
{

    public virtual int Number
    {
        get;
        set;
    }

    public virtual Action Action
    {
        get;
        set;
    }

    public Version()
    {
    }
}

现在我有一个代码段如下：

    var actionRep = new Repository<Action>();
    var versionRep = new Repository<Version>();

    var act1 = new Action( );
    actionRep .SaveOrUpdate( act1 );

    using (versionRep .DbContext.BeginTransaction())
    {

        var v1 = new Version();
        act1.AddVersion( v1 );
        //versionRep .SaveOrUpdate( v1 );
        versionRep .DbContext.CommitTransaction();
    }

在上面的代码中我只是创建操作和版本存储库。 首先，我使用 Action Repository 保存一个 Action 对象。然后我开始 使用版本存储库的事务，创建新版本，设置 引用操作，并提交事务而不 实际上调用版本存储库。

结果有点奇怪。版本对象甚至会被持久化 虽然我没有在版本存储库上调用 SaveOrUpdate 方法。如果 我注释掉了 act1.AddVersion( v1 ); 行在交易内， 那么版本不会被持久化。

经过一番努力，我使用 NHibernate 测试了相同的场景 直接而不是使用相同的 Sharp Architecture 存储库 流畅的映射/配置 (AutoPersistenceModelGenerator.Generate())。结果如下 预期的。版本对象不会被持久化。 的代码

    var sessionFactory = CreateSessionFactory();
    _act1 = new Action();

    using( var session = sessionFactory.OpenSession() )
    {
        session.SaveOrUpdate( _act1 );
    }

    using( var session = sessionFactory.OpenSession() )
    {
        using (var transaction = session.BeginTransaction())
        {
            _v1 = new Version();
            _act1.AddVersion( _v1 );
            //session.SaveOrUpdate( _act1 );
            transaction.Commit();
        }
    }

CreateSessionFactory()方法 如下。现在没什么复杂的

        private const string _dbFilename = "nhib_auditing.db";
        private static ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                .Database( SQLiteConfiguration.Standard
                            .UsingFile( _dbFilename )
                            .ShowSql())
                .Mappings( m => m.AutoMappings.Add( new
AutoPersistenceModelGenerator().Generate() ) )
                .ExposeConfiguration( BuildSchema )
                .BuildSessionFactory();
        }

如果有人可以请告诉我为什么我会这样 行为。这让我很生气。

只是为了让您知道我没有覆盖 Action 和 版本也可以。

等待中 纳比尔

Answer 1

如果您在映射中声明了级联操作，则这是预期的行为。当您在 act1 上调用 SaveOrUpdate 时，您使瞬态对象变得持久化；也就是说，NHibernate 正在跟踪它，并会在会话刷新时保存它。使对象持久化的另一种方法是将其与持久对象关联起来，就像调用 act1.AddVersion( v1 ); 时所做的那样。提交事务时会话被刷新，因此 v1 被保存。 本文介绍了详细信息与持久对象一起工作。

Answer 2

顺便说一句，这是我的两个测试，其中一个是使用 SharpRepositories
失败，然后使用 NHibernate Directly 正在通过。

    [TestFixture]
    public class RepositoryTests : RepositoryTestsBase
    {
        protected override void LoadTestData()
        {
        }

        [Test]
        public void TestUsingSharpRespositories
        {
            var aRep = new Repository<Action>();
            var vRep = new Repository<Version>();

            _act1 = new Action();
            aRep.SaveOrUpdate( _act1 );

            using( vRep.DbContext.BeginTransaction() )
            {
                _v1 = new Version();
                _act1.AddVersion( _v1 );
                //vRep.SaveOrUpdate(_v1);
                vRep.DbContext.CommitTransaction();
            }
            _v1.IsTransient().ShouldBeTrue();
        }

        [Test]
        public void TestUsingNHibernateSession
        {
            var sessionFactory = CreateSessionFactory();
            _act1 = new Action();

            using( var session = sessionFactory.OpenSession() )
            {
                session.SaveOrUpdate( _act1 );
            }

            using( var session = sessionFactory.OpenSession() )
            {
                using (var transaction = session.BeginTransaction())
                {
                    _v1 = new Version();
                    _act1.AddVersion( _v1 );

                    transaction.Commit();
                }
            }

            _v1.IsTransient().ShouldBeTrue();
        }

        private const string _dbFilename = "nhib_db.db";
        private static ISessionFactory CreateSessionFactory()
        {
            return Fluently.Configure()
                .Database( SQLiteConfiguration.Standard
                            .UsingFile( _dbFilename )
                            .ShowSql())
                .Mappings( m => m.AutoMappings.Add( new
AutoPersistenceModelGenerator().Generate() ) )
                .ExposeConfiguration( BuildSchema )
                .BuildSessionFactory();
        }

        private static void BuildSchema( Configuration config )
        {
            if( File.Exists( _dbFilename ) )
                File.Delete( _dbFilename );
            new SchemaExport( config ).Create( false, true );
        }
    }

我是 Fluent NHibernate 的新手，从未直接使用 NHibernate 进行 xml 映射。

就映射而言，我使用的是普通自动映射配置，该配置是在 Visual Studio 中创建新的 Sharp Architecture 项目时设置的。我对 HasMany 有如下约定：

public class HasManyConvention : IHasManyConvention
    {
        public void
Apply( FluentNHibernate.Conventions.Instances.IOneToManyCollectionInstance
instance )
        {
            instance.Key.Column( instance.EntityType.Name + "Fk" );
            instance.Inverse();
            instance.Cascade.All();
        }
    } 

我按如下方式更新了 TestUsingNHibernateSession 测试，以测试在单个会话中同时操作 Action 和 Version 时它的行为方式。你猜怎么着，即使事务的开始和提交之间没有任何内容，版本对象也会被保存。

    [Test]
    public void TestUsingNHibernateSession
    {
        var sessionFactory = CreateSessionFactory();
        _act1 = new Action();

        using( var session = sessionFactory.OpenSession() )
        {
            session.SaveOrUpdate( _act1 );
        //}

        //using( var session = sessionFactory.OpenSession() )
        //{
            _v1 = new Version();
            _act1.AddVersion( _v1 );
            using (var transaction = session.BeginTransaction())
            {
                transaction.Commit();
            }
        }

        _v1.IsTransient().ShouldBeTrue();
    }

所以我的结论是，这一切都与会议有关。如果在会话中创建或检索了对象 A，然后如果在该会话中开始新事务，则一旦提交该事务，与对象 A 关联的所有瞬态或脏对象也会被保存，不无论对象是在 Begin 和 Commit 内部还是外部创建的。

如果有人同意我的理解，可以告诉我吗？我还假设 Sharp 架构在每个 Web 请求中使用单个 nhibernate 会话？

等待中
纳比尔