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

标签：高并发   process   基础上   line   atom   system   包括   order   理解   

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

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

例2：

1. public class Test  
2.     {  
3.         SqlConnection conn = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI");  
4.         public void 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.     }  

1. public class DisplayTransactioninfo  
2.     {  
3.         public static void 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.         }  

1. public class 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.         public void 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.     }  

1. [System.Runtime.InteropServices.ComVisible(true)]  
2. //COM+是在COM的基础上发展起来的，需要将.NET程序集中的类型公开为COM组件。  
3.     [System.EnterpriseServices.Transaction(TransactionOption.Required)]//始终需要事务处理域  
4.     public class Test2 : ServicedComponent  
5.     {  
6.         public Test2() { }  
7.         SqlConnection conn = new SqlConnection("data source=.;Initial Catalog=DataMedicine;Integrated Security=SSPI");  
8.         [AutoComplete(true)]  
9. //如果在方法的执行体类没有出现错误，那么将自动设置事务处理的结果  
10.         public void 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.     }  

1. public class 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.         public void 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.         public static void 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.     }  

1. public class 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.         public void 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.     }  

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

1. //服务类1：  
2. public class 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.         public void 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. public class 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.         public void 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.         }  
18.  

服务配置：

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.  
16. static void Current_TransactionCompleted(object sender, TransactionEventArgs e)  
17.         {  
18.             if (e.Transaction.TransactionInformation.Status ==  
19.                 System.Transactions.TransactionStatus.Committed)  
20.                 Console.WriteLine(e.Transaction.TransactionInformation.DistributedIdentifier);  
21.         }  

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

标签：高并发   process   基础上   line   atom   system   包括   order   理解   

原文地址：http://www.cnblogs.com/proxyz/p/6056654.html