The commonly accepted standard
mechanism for handling distributed transactions is the two-phase commit protocol.
什么是两阶段提交协议 two-phase commit
实现分布式事务的关键就是两阶段提交协议。在此协议中,一个或多个资源管理器的活动均由一个称为事务协调器的单独软件组件来控制。
1)
应用程序调用事务协调器中的提交方法
2) 事务协调器将联络事务中涉及的每个资源管理器,并通知它们准备提交事务(这是第一阶段的开始)
3)
为 了以肯定的方式响应准备阶段,资源管理器必须将自己置于以下状态:确保能在被要求提交事务时提交事务,或在被要求回滚事务时回滚事务。大多数资源管理器会 将包含其计划更改的日记文件(或等效文件)写入持久存储区中。如果资源管理器无法准备事务,它会以一个否定响应来回应事务协调器。
4)
事务协调器收集来自资源管理器的所有响应
5)
在 第二阶段,事务协调器将事务的结果通知给每个资源管理器。如果任一资源管理器做出否定响应,则事务协调器会将一个回滚命令发送给事务中涉及的所有资源管理 器。如果资源管理器都做出肯定响应,则事务协调器会指示所有的资源管理器提交事务。一旦通知资源管理器提交,此后的事务就不能失败了。通过以肯定的方式响 应第一阶段,每个资源管理器均已确保,如果以后通知它提交事务,则事务不会失败
The
OASIS organization has proposed the Web Services Atomic Transaction (WS-AtomicTransaction)
specification, which describes a standard mechanism for handling transactions in a Web services
infrastructure.The WS-AtomicTransaction specification is primarily useful when building Web services. However,
WCF is not just concerned with Web services; you can use WCF to build applications
based on many other technologies, such as COM, MSMQ, and .NET Framework Remoting.
Microsoft has provided its own transaction management features, which are built in to the current family of Microsoft Windows operating systems under the name Distributed Transaction
Coordinator, or DTC. DTC uses its own optimized transaction protocol. Transactions based
on the DTC transaction protocol are referred to as OLE transactions (OLE was the name of a
technology that was the forerunner of COM). OLE transactions are ideal if you are building
solutions based on Microsoft technologies.
Service:
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession,
TransactionIsolationLevel=IsolationLevel.RepeatableRead)]
public class ShoppingCartServiceImpl : IShoppingCartService
{
...
}
[OperationBehavior(TransactionScopeRequired=true, TransactionAutoComplete=false)]
public bool AddItemToCart(string productNumber)
{
...
}
**The
TransactionAutoComplete property specifies what happens to the transaction
when the operation finishes.
If you set this property to true, the transaction automatically
commits and makes all its changes permanent.
Setting this property to false keeps
the transaction active; the changes are not committed yet. The default value for this
property is true
Specifying a parameter of
TransactionFlowOption.Mandatory indicates that the client application
must create a transaction before calling this operation and must send the details of
this transaction as part of the SOAP message header when invoking the operation.
TransactionFlowOption.Allowed, which will use a transaction
created by the client if one exists (the WCF runtime will create a new transaction
if not)
TransactionFlowOption.NotAllowed, which causes the WCF runtime to disregard any client transaction and always create a new one
public interface IShoppingCartService
{
[OperationContract(Name = "AddItemToCart", IsInitiating = true)]
[TransactionFlow(TransactionFlowOption.Mandatory)]
bool AddItemToCart(string productNumber);
2)Configuration Service to Flow Transactions from Client Applications
![](http://hi.csdn.net/attachment/201203/18/10223170_1332083587S4at.png)
3)Create a Transaction in the Client Application
TransactionOptions tOpts = new TransactionOptions();
tOpts.IsolationLevel = IsolationLevel.RepeatableRead;
tOpts.Timeout = new TimeSpan(0, 1, 0);
using (TransactionScope tx =
new TransactionScope(TransactionScopeOption.RequiresNew, tOpts))
{
...
tx.Complete();
}
The TransactionScopeOption parameter of the TransactionScope constructor determines
how the WCF runtime utilizes an existing transaction. If this parameter is set to Transaction
ScopeOption.RequiresNew, the WCF runtime will always create a new transaction.
4)Configure the Client Application to Flow Transactions to the ShoppingCartService
Service
5)
[OperationBehavior(TransactionScopeRequired = true,
TransactionAutoComplete = false)]
public bool Checkout()
{
// Not currently implemented
// - just indicate that the transaction completed successfully
// and return true
OperationContext.Current.SetTransactionComplete();
return true;
}
The static Current property of the OperationContext class provides access to the execution
context of the operation.
The SetTransactionComplete method indicates that the
current transaction has completed successfully and can be committed when the client
application calls the Complete method of the TransactionScope object containing this
transaction.
If you need to abort the transaction, just exit the method without calling
the SetTransactionComplete method,
Additionally, you can call the SetTransactionComplete method only once in a transaction
Implementing the WS-AtomicTransaction Protocol
The NetTcpBinding binding uses OLE transactions and Microsoft’s own protocol for communicating
through DTC to other Microsoft-specific services such as SQL Server.
In a heterogeneous
environment involving services based on non-Microsoft technologies, you may not be
able to employ OLE transactions. Instead, you should apply a more standardized mechanism,such as the WS-AtomicTransaction protocol.
**Important The BasicHttpBinding binding does not support transactions (OLE or WS-Atomic
Transaction).such as the WS-AtomicTransaction protocol.
The choice of transaction protocol should be transparent to your services and client applications.
The code that you write to initiate, control, and support transactions based on the WSAtomicTransaction
protocol is the same as that for manipulating OLE transactions, so the same
service can execute using OLE transactions or WS-AtomicTransaction transactions, depending
on how you configure the service
If you wish to exploit the implementation of the WS-AtomicTransaction protocol provided by
the .NET Framework 4.0 with the HTTP bindings, you must configure support for the
WS-AtomicTransaction protocol in DTC.
Designing a WCF Service to Support Transactions
Transactions, Sessions, and Service Instance Context Modes
An important point to bear in mind from the points just raised is that transactions cannot span multiple sessions.