C# TransactionScope.VoteCommit方法代码示例

		public void CanIntegrateNHibernateAndActiveRecord()
		{
			ActiveRecordStarter.ModelsValidated += delegate
			{
				new ActiveRecordModelBuilder().CreateDummyModelFor(typeof(NHibernateClass));
			};
			ActiveRecordStarter.Initialize(
				GetConfigSource(),
				typeof(ActiveRecordClass),
				typeof(NHibernateClass));

			Recreate();

			using (TransactionScope tx = new TransactionScope())
			{
				ActiveRecordClass ar = new ActiveRecordClass();
				ar.Friend = new NHibernateClass();
				ActiveRecordMediator.Save(ar.Friend);
				ActiveRecordMediator.Save(ar);
				tx.VoteCommit();
			}

			using (TransactionScope tx = new TransactionScope())
			{
				ActiveRecordClass first = ActiveRecordMediator<ActiveRecordClass>.FindFirst();
				Assert.IsNotNull(first);
				Assert.IsNotNull(first.Friend);
			}
		}

        public void ExplicitFlushInsideSecondTransactionProblem()
        {
            ActiveRecordStarter.Initialize(GetConfigSource(),
                typeof(Company),
                typeof(Person),
                typeof(Blog),
                typeof(Post));
            Recreate();

            Company comp1 = new Company("comp1");
            Company comp2 = new Company("comp2");
            using(new SessionScope())
            {
                comp1.Create();
                comp2.Create();
            }

            using(new SessionScope(FlushAction.Never))
            {
                using(TransactionScope tx = new TransactionScope(OnDispose.Rollback))
                {
                    Company comp2a = Company.Find(comp2.Id);
                    comp2a.Name = "changed";
                    tx.VoteCommit();
                }

                using(new TransactionScope(OnDispose.Rollback))
                {
                    Company[] changedCompanies = ActiveRecordMediator<Company>.FindAllByProperty("Name", "changed");
                    Assert.AreEqual(1, changedCompanies.Length);
                    Company e2a = changedCompanies[0];
                    e2a.Delete();

                    SessionScope.Current.Flush();

                    Assert.AreEqual(0, ActiveRecordMediator<Company>.FindAllByProperty("Name", "changed").Length);
                }
            }
        }

		public void ValidateIsUniqueWithinTransactionScope()
		{
			ActiveRecordStarter.Initialize( GetConfigSource(), typeof(Blog2) );
			Recreate();
			
			// The IsUniqueValidator was created a new SessionScope and causing an
			// error when used inside TransactionScope
			
			using (TransactionScope scope = new TransactionScope())
			{
				Blog2 blog = new Blog2();
				blog.Name = "A cool blog";
				blog.Create();
					
				blog = new Blog2();
				blog.Name = "Another cool blog";
				blog.Create();
				
				scope.VoteCommit();
			}
		}

		public void NestedTransactionWithRollbackOnDispose()
		{
			ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
			Recreate();

			Post.DeleteAll();
			Blog.DeleteAll();

			using(new TransactionScope())
			{
				Blog blog = new Blog();

				using(TransactionScope t1 = new TransactionScope(TransactionMode.Inherits, OnDispose.Rollback))
				{
					blog.Author = "hammett";
					blog.Name = "some name";
					blog.Save();

					t1.VoteCommit();
				}

				using(TransactionScope t2 = new TransactionScope(TransactionMode.Inherits, OnDispose.Rollback))
				{
					Post post = new Post(blog, "title", "post contents", "Castle");

					try
					{
						post.SaveWithException();

						t2.VoteCommit(); // Will never be called
					}
					catch(Exception)
					{
						// t2.VoteRollBack();
					}
				}
			}

			Blog[] blogs = Blog.FindAll();
			Assert.AreEqual(0, blogs.Length);

			Post[] posts = Post.FindAll();
			Assert.AreEqual(0, posts.Length);
		}

		public void MixingSessionScopeAndTransactionScopes()
		{
			ActiveRecordStarter.Initialize(GetConfigSource(), typeof(Post), typeof(Blog));
			Recreate();

			Post.DeleteAll();
			Blog.DeleteAll();

			using(new SessionScope())
			{
				using(TransactionScope root = new TransactionScope())
				{
					using(TransactionScope t1 = new TransactionScope()) // Isolated
					{
						Blog blog = new Blog();

						Blog.FindAll(); // Just to force a session association

						using(new TransactionScope(TransactionMode.Inherits))
						{
							Blog.FindAll(); // Just to force a session association

							blog.Author = "hammett";
							blog.Name = "some name";
							blog.Save();
						}

						using(new TransactionScope(TransactionMode.Inherits))
						{
							Post post = new Post(blog, "title", "post contents", "Castle");

							post.Save();
						}

						t1.VoteRollBack();
					}

					Blog.FindAll(); // Cant be locked

					using(new TransactionScope())
					{
						Blog blog = new Blog();
						Blog.FindAll(); // Just to force a session association

						using(new TransactionScope())
						{
							Blog.FindAll(); // Just to force a session association

							blog.Author = "hammett";
							blog.Name = "some name";
							blog.Save();
						}

						using(TransactionScope t1n = new TransactionScope(TransactionMode.Inherits))
						{
							Post post = new Post(blog, "title", "post contents", "Castle");

							try
							{
								post.SaveWithException();
							}
							catch(Exception)
							{
								t1n.VoteRollBack();
							}
						}
					}

					root.VoteCommit();
				}
			}

			Blog[] blogs = Blog.FindAll();
			Assert.AreEqual(1, blogs.Length);

			Post[] posts = Post.FindAll();
			Assert.AreEqual(0, posts.Length);
		}

 public void UsingTransactionScopeWithCommitAndInnerSessionScope()
 {
     using (TransactionScope scope = new TransactionScope())
     {
         using (new SessionScope())
         {
             new SSAFEntity("example").Save();
             Assert.AreEqual(1, SSAFEntity.FindAll().Count());
         }
         //Assert.AreEqual(1, SSAFEntity.FindAll().Length);
         scope.VoteCommit();
     }
     using (new SessionScope())
         Assert.AreEqual(1, SSAFEntity.FindAll().Count());
 }