Ejemplo n.º 1
0
        public void TransactionManagerRollsbackAmbientTransactionsOnAllThreads()
        {
            var seed = new Seed32();

            using (var manager = new TransactionManager<int, MockClassA>() )
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        transaction.MarkComplete();

                        Assert.Fail();
                    });

                var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                testEntities.ForEach(e => e.Id = seed.Increment());

                using (var tLock1 = manager.GetActiveTransaction(false))
                {
                    foreach (var entity in testEntities)
                        tLock1.Transaction.Enlist(Action.Create, entity.Id, entity);

                    using (var tLock2 = manager.GetActiveTransaction(false))
                    {
                        testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                        testEntities.ForEach(e => e.Id = seed.Increment());

                        foreach (var entity in testEntities)
                            tLock2.Transaction.Enlist(Action.Create, entity.Id, entity);

                        manager.RollBackAll(true);
                    }
                }

                Assert.AreEqual(manager.GetCached().Count(), 0);
            }
        }
Ejemplo n.º 2
0
        public void TransactionManagerCommitAllCommitsAllTransactions()
        {
            var sync = new object();
            var seed = new Seed32();
            var hits = 0;

            using (var manager = new TransactionManager<int, MockClassA>())
            {
                manager.TransactionCommitted += new TransactionCommit<int, MockClassA>
                    (delegate(ITransaction<int, MockClassA> transaction)
                    {
                        Assert.AreEqual(3, transaction.GetEnlistedActions().Count());
                        hits++;

                        transaction.MarkComplete();
                    });

                var transList = new List<TransactionLock<int, MockClassA>>();

                Parallel.For(0, 5, delegate(int i)
                {
                    var testEntities = TestResourceFactory.GetMockClassAObjects(3).ToList();
                    testEntities.ForEach(e => e.Id = seed.Increment());

                    var trans = manager.BeginTransaction();

                    foreach (var entity in testEntities)
                        trans.Transaction.Enlist(Action.Create, entity.Id, entity);

                    if (i == 1)
                    {
                        lock (sync)
                            transList.Add(trans);

                        Assert.AreEqual(3, manager.GetCached().Count());
                    }
                    else
                        trans.Transaction.Commit();

                });

                manager.CommitAll(true);

                Assert.AreEqual(0, manager.GetCached().Count());
            }

            Assert.AreEqual(5, hits);
        }