.NET简谈事务、分布式事务处理

在本人的 “.NET简谈事务本质论”一文中我们从整体上了解了事务模型，在我们脑子里能有一个全局的事务处理结构，消除对数据库事务的依赖理解，重新认识事务编程模型。

　　今天这篇文章我们将使用.NET C#来进行事务性编程，从浅显、简单的本地事务开始，也就是我们用的最多的ADO.NET事务处理，然后我们逐渐扩大事务处理范围，包括对分布式事务处理的使用，多线程事务处理的使用。

　　数据库事务处理

　　数据库事务处理我们基本都很熟悉了，begin Transaction ……end Transaction，将要进行事务性的操作包在代码段里，为了便于文章有条理的讲解下去，我还是在这里穿插一个简单的小示例，便于与后面的代码进行对比分析。

　　例1：

　　我们在数据库里建两张表，也就是很简单一列信息。

　　表1名：test

　　表2名：test2

　　目的是为了掩饰事务的特性，所以我们这里给表1test的name列设置为主键，我们后面将通过有意的造成主键重复，导致事务自动回滚的效果。

　　我先来解释一下这两张表后面干什么用的。表test是用来有意造成事务内部处理出错用的，表test2是用来在事务处理当中扮演着没有错误的常规数据插入用的，我会在test2中先插入数据，然后在test中插入数据时触发事务内部执行错误导致事务回滚。

　　好了我们进行T-SQL的编写：

1. insertinto test values('222') --我们在表test中插入一条记录
2. go 
3. begintransaction tr 
4. begin try 
5. begin
6. insertinto test2 values('111') 
7. insertinto test values('222') --该行插入会导致主键冲突，也就是我们要的效果
8. end
9. committransaction tr 
10. end try 
11. begin catch 
12. print '事务执行错误!'
13. print error_number() 
14. rollbacktransaction tr     
15. end catch

 

　　我们运行看看结果：

　　在事务处理过程中，很明显第一条插入语句执行成功了，但是由于第二条插入语句导致事务回滚所以数据是没有变化的。

　　这个示例可能过于简单，真正的企业级应用可能很复杂，但是我们的目的是看看事务的使用，越简单越明了越好。

ADO.NET事务处理

　　下面我们将事务在.NET的AOD.NET中实现看看效果。

　　例2：

1. publicclass Test 
2.     { 
3.         SqlConnection conn = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
4.         publicvoid Add() 
5.         { 
6.             conn.Open(); 
7.             SqlCommand command = new SqlCommand("insert into test2 values(111)", conn); 
8.             try
9.             { 
10.                 command.Transaction = conn.BeginTransaction(); 
11.                 command.ExecuteNonQuery(); 
12.                 command.CommandText = "insert into test values(222)"; 
13.                 command.ExecuteNonQuery(); 
14.                 command.Transaction.Commit(); 
15.             } 
16.             catch (Exception err) 
17.             { 
18.                 Console.WriteLine(err); 
19.                 command.Transaction.Rollback(); 
20.             } 
21.         } 
22.     }

 

　　这就是典型ADO.NET事务处理代码，其实和我们第一个例子中的T-SQL代码是差不多的，通过ADO.NET中的SqlConnection.BeginTransaction()获取到对底层ODBC中的数据库事务的引用，其实这里还没有真正的设计到.NET中的事务处理代码，这里只是对数据库管理系统的远程调用，通过远程处理的消息通讯进行事务处理远程化。

　　事务信息显示类，为了便于观察事务的状态信息。

1. publicclass DisplayTransactioninfo 
2.     { 
3.         publicstaticvoid Display(System.Transactions.Transaction tr) 
4.         { 
5.             if (tr != null) 
6.             { 
7.                 Console.WriteLine("Createtime:" + tr.TransactionInformation.CreationTime); 
8.                 Console.WriteLine("Status:" + tr.TransactionInformation.Status); 
9.                 Console.WriteLine("Local ID:" + tr.TransactionInformation.LocalIdentifier); 
10.                 Console.WriteLine("Distributed ID:" + tr.TransactionInformation.DistributedIdentifier); 
11.                 Console.WriteLine(); 
12.             } 
13.         }

 

　　CommittableTransaction事务处理

　　从这里开始我们将接触到.NET中的事务处理，将了解到.NET中事务是怎样影响到远程数据库管理系统的事务处理的。

　　其实事务处理是一个非常复杂的技术领域，需要考虑很多可逆的技术实现，我们只是简单的了解原理和掌握基本的运用。

　　在我的“.NET简谈事务本质论”一文中说到了事务的传递原理，那么事务传递意味着什么。其实事务传递的大概意思是将事务的执行范围通过网络传输的方式进行扩大到其他的机器上，比如我们在.NET中执行一项关于事务性的操作，那么在这个操作里面我们包含了对数据库的操作，这个时候对数据库的一系列操作都应该是属于事务范围内的，当事务回滚时还应该将数据库中的数据进行回滚才对。但是我们不可能总是显示的执行ADO.NET中的BeginTransaction，对于本地事务处理也就是单一资源管理器来说这也可以接受，那么如果在事务范围内涉及到多个资源管理器的操作，这就是分布式事务处理的范围了。所以说事务处理需要跨越网络传输形成无缝的面向服务的事务处理，数据库管理系统即有可能扮演者事务管理器的角色也有可能扮演着资源管理器的角色。太多的理论知识我这里就不多扯了，我们还是来看代码吧。

接着上面的实例，我们现在通过.NET中的事务处理来进行自动化的数据库事务处理。让数据库能自动的感知到我们正在进行事务性的操作。

　　例3：

　　我们利用Transaction类的子类CommittableTransaction可提交事务类来进行事务编程。

1. publicclass Test3 
2.     { 
3.         SqlConnection conn; 
4.         CommittableTransaction committran = new CommittableTransaction(); 
5.         public Test3() 
6.         { 
7.             conn = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
8.             DisplayTransactioninfo.Display(committran); 
9.         } 
10.         publicvoid Add3() 
11.         { 
12.             conn.Open(); 
13.             conn.EnlistTransaction(committran);//需要将本次的连接操作视为事务性的
14.             SqlCommand command = new SqlCommand(); 
15.             try
16.             { 
17.                 command.Connection = conn; 
18.                 command.CommandText = "insert into test2 values(111)"; 
19.                 command.ExecuteNonQuery(); 
20.                 command.CommandText = "insert into test values(222)"; 
21.                 command.ExecuteNonQuery(); 
22.                 committran.Commit(); 
23.             } 
24.             catch (Exception err) { committran.Rollback(); //出现出错执行回滚操作}
25.         } 
26.     }

 

　　数据源连接对象代表着远程数据库资源，所以在执行操作之前我们需要将资源管理器添加到本地事务管理器中进行后期的投票、提交管理。

　　EnterpriseService(COM+)自动化事务处理

　　在.NET2.0中有一个程序集不是太被人重视，System.EnterpriseServices.dll，这个程序集是.NET中为了使用早起的COM+技术的托管程序集，我们可以使用这个程序集来编写一些我们以前所不能编写的COM+应用程序。至于COM+应用程序的介绍网上一大堆，随便搜搜就有好多资料了，我印象中有一篇是潘爱明潘老师写的一个文章蛮好的，就是介绍COM+的所有特性。

　　我们继续来事务处理，下面我们看看怎么借用System.EnterpriseServices.Transaction类来进行自动化的事务处理。

　　例4：

1. [System.Runtime.InteropServices.ComVisible(true)] 
2. //COM+是在COM的基础上发展起来的，需要将.NET程序集中的类型公开为COM组件。
3.     [System.EnterpriseServices.Transaction(TransactionOption.Required)]//始终需要事务处理域
4.     publicclass Test2 : ServicedComponent 
5.     { 
6.         public Test2() { } 
7.         SqlConnection conn = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
8.         [AutoComplete(true)] 
9. //如果在方法的执行体类没有出现错误，那么将自动设置事务处理的结果
10.         publicvoid Add2() 
11.         { 
12.             conn.Open(); 
13.             SqlCommand command = new SqlCommand(); 
14.             try
15.             { 
16.                 command.Connection = conn; 
17.                 command.CommandText = "insert into test2 values(111)"; 
18.                 command.ExecuteNonQuery(); 
19.                 command.CommandText = "insert into test values(222)"; 
20.                 command.ExecuteNonQuery(); 
21.             } 
22.             catch { System.EnterpriseServices.ContextUtil.SetAbort(); } 
23.         } 
24.     }

 

　　DependentTransaction跨线程事务处理

　　我们在编写高并发量程序时，都会用到多线程来进行处理，让主线程能有时间来处理第一线的请求，然后将请求分发到各个子线程上进行后台的处理。我们来看一幅图：

　　我们假设上面这幅图是我们系统的一个内部结构，主线程主要的任务就是接受外来的请求，然后将具体的任务完成放到一个到两个子线程中去完成，但是子线程与子线程之间没有必然的关系，由于事务的上下文是不夸线程的，那么怎么将两个或者更多的线程串在一个事务里。

我们来看看依赖事务处理，看代码：

　　例5：

1. publicclass Test6 
2.     { 
3.         CommittableTransaction commit = new CommittableTransaction(); 
4.         SqlConnection conn1 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
5.         public Test6() 
6.         { 
7.             conn1.Open(); 
8.             conn1.EnlistTransaction(commit); 
9.         } 
10.         publicvoid Add6() 
11.         { 
12.             try
13.             { 
14.                 DisplayTransactioninfo.Display(commit); 
15.                 SqlCommand command = new SqlCommand("insert into test2 values(111)", conn1); 
16.                 command.ExecuteNonQuery(); 
17.                 Thread thread = new Thread(Test6.CommitThread); 
18.             thread.Start(commit.DependentClone(DependentCloneOption.BlockCommitUntilComplete)); 
19.                 commit.Commit(); 
20.             } 
21.             catch (Exception err) { commit.Rollback(); } 
22.         } 
23.         publicstaticvoid CommitThread(object co) 
24.         { 
25.             DependentTransaction commit = co as DependentTransaction; 
26.             SqlConnection conn2 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
27.             conn2.Open(); 
28.             conn2.EnlistTransaction(commit as DependentTransaction); 
29.             DisplayTransactioninfo.Display(commit); 
30.             SqlCommand command = new SqlCommand("insert into test values(111)", conn2); 
31.             try
32.             { 
33.                 command.ExecuteNonQuery(); 
34.                 commit.Complete(); 
35.             } 
36.             catch (Exception err) { Console.WriteLine(err); commit.Rollback(); } 
37.         } 
38.     }

 

　　我们用一个子线程来执行另外的一个事务处理，由于是依赖事务处理，所以主事务处理完成后要等待子事务处理的结果。其实本例子已经是涉及到分布式事务处理的范围了，当事务范围内有一个以上的资源管理器时，本地事务管理器将自动提升为DTC管理器，下面我们来看看分布式事务处理。

　　DTC(Distributed Transaction Coordinator) 分布式事务处理

　　分布式事务在开发中经常是被用到，也必须被用到。必须同步数据、上下文更新等等。

　　按照使用方式的不同分布式事务的复杂程度也不同，基于本地事务的多资源管理器和基于SOA的面向服务的多资源管理器。

　　由于本地事务处理是基于本地事务管理器的，所以它不能管理分布式的事务，一旦当我们处理的事务范围要进行扩大时并且是夸机器的访问时，那么本地事务管理器将自动提升为分布式事务管理器也就是DTC（分布式事务协调器）。

　　例6：

1. publicclass Test4 
2.     { 
3.         SqlConnection conn1 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
4.         SqlConnection conn2 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI"); 
5.         CommittableTransaction committran = new CommittableTransaction(); 
6.         public Test4() 
7.         { 
8.             DisplayTransactioninfo.Display(committran); 
9.             conn1.Open(); 
10.             conn1.EnlistTransaction(committran); 
11.             conn2.Open(); 
12.             conn2.EnlistTransaction(committran); 
13.             DisplayTransactioninfo.Display(committran); 
14.         } 
15.         publicvoid Add4() 
16.         { 
17.             try
18.             { 
19.                 SqlCommand command1 = new SqlCommand("insert into test2 values(111)", conn1); 
20.                 command1.ExecuteNonQuery(); 
21.                 SqlCommand command2 = new SqlCommand("insert into test values(222)", conn2); 
22.                 command2.ExecuteNonQuery(); 
23.             } 
24.             catch (Exception err) { Console.WriteLine(err); committran.Rollback(); } 
25.         } 
26.     }

一旦我们开启分布式事务处理就能在我们的电脑上的DTC管理器上看见到。

　　但是要记得检查你的DTC服务是否开启了。

　　基于WCF框架的分布式事务处理

　　其实基于WCF框架进行分布式事务开发真的很轻松，它能很好的感知到当前上下文是不是事务域，并能很好的将事务序列化到服务这边来。但是设计一个高性能的分布式事务处理框架并非易事，需要很长时间的积累和实践。我们来看一下WCF是如果进行分布式事务处理的。

　　例7：

1. //服务契约(ServiceContract):
2. [ServiceContract(SessionMode = SessionMode.Required)] 
3.     publicinterface IDistributedTransaction 
4.     { 
5.         [TransactionFlow(TransactionFlowOption.Allowed)] 
6.         [OperationContract] 
7.         void Add(); 
8.     }

 

1. //服务类1：
2. publicclass DistributedTransactionService1 : IDistributedTransaction 
3.     { 
4.         SqlConnection conn1 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI");
5.         #region IDistributedTransaction
6.         [OperationBehavior(TransactionAutoComplete = true, TransactionScopeRequired = true)] 
7.         publicvoid Add() 
8.         { 
9.             conn1.Open(); 
10.             SqlCommand command = new SqlCommand("insert into test2 values(111)", conn1); 
11.             command.ExecuteNonQuery(); 
12.             DataBaseOperation.DisplayTransactioninfo.Display(System.Transactions.Transaction.Current); 
13.         }
14.         #endregion
15.     }

 

1. //服务类2：
2. publicclass DistributedTransactionService2 : IDistributedTransaction 
3.     { 
4.         SqlConnection conn2 = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI");
5.         #region IDistributedTransaction
6.         [OperationBehavior(TransactionAutoComplete = true, TransactionScopeRequired = true)] 
7.         publicvoid Add() 
8.         { 
9.             conn2.Open(); 
10.             SqlCommand command = new SqlCommand("insert into test values(222)", conn2); 
11.             try
12.             { 
13.                 DataBaseOperation.DisplayTransactioninfo.Display(System.Transactions.Transaction.Current); 
14.                 command.ExecuteNonQuery(); 
15.             } 
16.             catch (Exception err) { throw err; } 
17.         }

服务配置：

1. <service name="ServerConsole.Transaction.DistributedTransactionService1" behaviorConfiguration="metadatabehaviors"> 
2.         <host> 
3.           <baseAddresses> 
4.             <add baseAddress="http://localhost:8027"/> 
5.             <add baseAddress="net.tcp://localhost:8028"/> 
6.           </baseAddresses> 
7.         </host> 
8.         <endpoint address="DistributedTransactionService1" binding="netTcpBinding" bindingConfiguration="tranbinding"
9.                    contract="ServerConsole.Transaction.IDistributedTransaction"></endpoint> 
10.       </service> 
11.       <service name="ServerConsole.Transaction.DistributedTransactionService2" behaviorConfiguration="metadatabehaviors"> 
12.         <host> 
13.           <baseAddresses> 
14.             <add baseAddress="http://localhost:8029"/> 
15.             <add baseAddress="net.tcp://localhost:8030"/> 
16.           </baseAddresses> 
17.         </host> 
18.         <endpoint address="DistributedTransactionService2" binding="netTcpBinding" bindingConfiguration="tranbinding"
19.                 contract="ServerConsole.Transaction.IDistributedTransaction"></endpoint> 
20.       </service>

 

　　Binding配置：

1. <bindings> 
2.       <netTcpBinding> 
3.         <binding name="tranbinding" transactionFlow="true" transactionProtocol="WSAtomicTransactionOctober2004"> 
4.           <reliableSession enabled="true" ordered="true"/> 
5.         </binding> 
6.       </netTcpBinding> 
7.     </bindings>

 

　　我们需要打开Binding的事务流传递。

　　客户端代码：

1. 客户端： 
2. DistributedTransactionClient.DistributedTransactionClient tranclient = new DistributedTransactionClient.DistributedTransactionClient(); 
3.             DistributedTransaction2Client.DistributedTransactionClient tranclient2 = new DistributedTransaction2Client.DistributedTransactionClient(); 
4.             using (TransactionScope transcope = new TransactionScope()) 
5.             { 
6.                 try
7.                 { 
8.                     Transaction.Current.TransactionCompleted += new TransactionCompletedEventHandler(Current_TransactionCompleted); 
9.                     tranclient.Add(); 
10.                     tranclient2.Add(); 
11.                     transcope.Complete(); 
12.                 } 
13.                 catch (Exception err) { Transaction.Current.Rollback(); } 
14.             } 
15. staticvoid Current_TransactionCompleted(object sender, TransactionEventArgs e) 
16.         { 
17.             if (e.Transaction.TransactionInformation.Status == 
18.                 System.Transactions.TransactionStatus.Committed) 
19.                 Console.WriteLine(e.Transaction.TransactionInformation.DistributedIdentifier); 
20.         }

 

　　客户端使用TransactionScope类来进行环境事务的设置，这样就很方便知道事务的执行范围，在TransactionScope里面我们可以通过Transaction.Current获取到当前上下文的事务对象，由于事务对象是存储在线程独立存储区里的，所以跨线程访问是没用的，通过依赖事务进行传递。

　　文章到这里就讲完了，从本地事务、多资源管理器分布式事务、SOA结构的分布式事务，我们都能进行基本的掌握。上面的例子都是经过严格测试的。