TransactionScope TransactionScope TransactionScope TransactionScope Class

定義

使程式碼區塊成為異動式。Makes a code block transactional. 這個類別無法被繼承。This class cannot be inherited.

public ref class TransactionScope sealed : IDisposable
public sealed class TransactionScope : IDisposable
type TransactionScope = class
    interface IDisposable
Public NotInheritable Class TransactionScope
Implements IDisposable
繼承
TransactionScopeTransactionScopeTransactionScopeTransactionScope
實作

範例

下列範例示範如何使用TransactionScope類別來定義參與交易的程式碼區塊。The following example demonstrates how to use the TransactionScope class to define a block of code to participate in a transaction.

// This function takes arguments for 2 connection strings and commands to create a transaction 
// involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the 
// transaction is rolled back. To test this code, you can connect to two different databases 
// on the same server by altering the connection string, or to another 3rd party RDBMS by 
// altering the code in the connection2 code block.
static public int CreateTransactionScope(
    string connectString1, string connectString2,
    string commandText1, string commandText2)
{
    // Initialize the return value to zero and create a StringWriter to display results.
    int returnValue = 0;
    System.IO.StringWriter writer = new System.IO.StringWriter();

    try
    {
        // Create the TransactionScope to execute the commands, guaranteeing
        // that both commands can commit or roll back as a single unit of work.
        using (TransactionScope scope = new TransactionScope())
        {
            using (SqlConnection connection1 = new SqlConnection(connectString1))
            {
                // Opening the connection automatically enlists it in the 
                // TransactionScope as a lightweight transaction.
                connection1.Open();

                // Create the SqlCommand object and execute the first command.
                SqlCommand command1 = new SqlCommand(commandText1, connection1);
                returnValue = command1.ExecuteNonQuery();
                writer.WriteLine("Rows to be affected by command1: {0}", returnValue);

                // If you get here, this means that command1 succeeded. By nesting
                // the using block for connection2 inside that of connection1, you
                // conserve server and network resources as connection2 is opened
                // only when there is a chance that the transaction can commit.   
                using (SqlConnection connection2 = new SqlConnection(connectString2))
                {
                    // The transaction is escalated to a full distributed
                    // transaction when connection2 is opened.
                    connection2.Open();

                    // Execute the second command in the second database.
                    returnValue = 0;
                    SqlCommand command2 = new SqlCommand(commandText2, connection2);
                    returnValue = command2.ExecuteNonQuery();
                    writer.WriteLine("Rows to be affected by command2: {0}", returnValue);
                }
            }

            // The Complete method commits the transaction. If an exception has been thrown,
            // Complete is not  called and the transaction is rolled back.
            scope.Complete();

        }
       
    }
    catch (TransactionAbortedException ex)
    {
        writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message);
    }

    // Display messages.
    Console.WriteLine(writer.ToString());

    return returnValue;
}
'  This function takes arguments for 2 connection strings and commands to create a transaction 
'  involving two SQL Servers. It returns a value > 0 if the transaction is committed, 0 if the 
'  transaction is rolled back. To test this code, you can connect to two different databases 
'  on the same server by altering the connection string, or to another 3rd party RDBMS  
'  by altering the code in the connection2 code block.
Public Function CreateTransactionScope( _
  ByVal connectString1 As String, ByVal connectString2 As String, _
  ByVal commandText1 As String, ByVal commandText2 As String) As Integer

    ' Initialize the return value to zero and create a StringWriter to display results.
    Dim returnValue As Integer = 0
    Dim writer As System.IO.StringWriter = New System.IO.StringWriter

    Try
    ' Create the TransactionScope to execute the commands, guaranteeing
    '  that both commands can commit or roll back as a single unit of work.
        Using scope As New TransactionScope()
            Using connection1 As New SqlConnection(connectString1)
                ' Opening the connection automatically enlists it in the 
                ' TransactionScope as a lightweight transaction.
                connection1.Open()

                ' Create the SqlCommand object and execute the first command.
                Dim command1 As SqlCommand = New SqlCommand(commandText1, connection1)
                returnValue = command1.ExecuteNonQuery()
                writer.WriteLine("Rows to be affected by command1: {0}", returnValue)

                ' If you get here, this means that command1 succeeded. By nesting
                ' the using block for connection2 inside that of connection1, you
                ' conserve server and network resources as connection2 is opened
                ' only when there is a chance that the transaction can commit.   
                Using connection2 As New SqlConnection(connectString2)
                    ' The transaction is escalated to a full distributed
                    ' transaction when connection2 is opened.
                    connection2.Open()

                    ' Execute the second command in the second database.
                    returnValue = 0
                    Dim command2 As SqlCommand = New SqlCommand(commandText2, connection2)
                    returnValue = command2.ExecuteNonQuery()
                    writer.WriteLine("Rows to be affected by command2: {0}", returnValue)
                End Using
            End Using

        ' The Complete method commits the transaction. If an exception has been thrown,
        ' Complete is called and the transaction is rolled back.
        scope.Complete()
        End Using
    Catch ex As TransactionAbortedException
        writer.WriteLine("TransactionAbortedException Message: {0}", ex.Message)
    End Try

    ' Display messages.
    Console.WriteLine(writer.ToString())

    Return returnValue
End Function

備註

System.Transactions基礎結構所提供的明確程式設計模型為基礎Transaction類別,以及隱含程式設計模型使用TransactionScope類別,以自動管理交易由基礎結構。The System.Transactions infrastructure provides both an explicit programming model based on the Transaction class, as well as an implicit programming model using the TransactionScope class, in which transactions are automatically managed by the infrastructure.

重要

我們建議您建立隱含的交易使用TransactionScope類別,以便為您自動管理環境交易內容。We recommend that you create implicit transactions using the TransactionScope class, so that the ambient transaction context is automatically managed for you. 您也應該使用TransactionScopeDependentTransaction需要使用相同的異動,跨多個函式呼叫或多個執行緒呼叫的應用程式的類別。You should also use the TransactionScope and DependentTransaction class for applications that require the use of the same transaction across multiple function calls or multiple thread calls. 如需有關此模型的詳細資訊,請參閱 < 實作隱含異動使用異動範圍主題。For more information on this model, see the Implementing An Implicit Transaction Using Transaction Scope topic. 如需有關如何撰寫交易式應用程式的詳細資訊,請參閱撰寫交易式應用程式For more information on writing a transactional application, see Writing A Transactional Application.

在具現化TransactionScopenew陳述式中,交易管理員會決定要參與哪個交易。Upon instantiating a TransactionScope by the new statement, the transaction manager determines which transaction to participate in. 一旦決定後,範圍永遠會參與該異動。Once determined, the scope always participates in that transaction. 此決策是根據兩個因素而定:環境異動是否存在,以及建構函式中的 TransactionScopeOption 參數值。The decision is based on two factors: whether an ambient transaction is present and the value of the TransactionScopeOption parameter in the constructor. 環境交易是您的程式碼中執行的交易。The ambient transaction is the transaction your code executes in. 您可以呼叫 Transaction.Current 類別的靜態 Transaction 屬性,取得環境交易的參考。You can obtain a reference to the ambient transaction by calling the static Transaction.Current property of the Transaction class. 如需有關如何使用此參數的詳細資訊,請參閱 < 交易流程管理 > 一節實作隱含異動使用異動範圍主題。For more information on how this parameter is used, see the "Transaction Flow Management" section of the Implementing An Implicit Transaction Using Transaction Scope topic.

如果在異動範圍內不發生的任何例外狀況 (也就是之間的初始設定TransactionScope物件並呼叫其Dispose方法),則範圍所參與的交易可以繼續。If no exception occurs within the transaction scope (that is, between the initialization of the TransactionScope object and the calling of its Dispose method), then the transaction in which the scope participates is allowed to proceed. 如果在異動範圍內,未發生例外狀況,它所參與的交易將會回復。If an exception does occur within the transaction scope, the transaction in which it participates will be rolled back.

當您的應用程式完成所有工作想要在交易中執行,您應該呼叫Complete方法一次,以通知交易管理員可以接受認可交易。When your application completes all work it wants to perform in a transaction, you should call the Complete method only once to inform that transaction manager that it is acceptable to commit the transaction. 無法呼叫這個方法會中止交易。Failing to call this method aborts the transaction.

呼叫Dispose方法會標記交易範圍的結尾。A call to the Dispose method marks the end of the transaction scope. 在呼叫這個方法後發生的例外狀況不太可能會影響異動。Exceptions that occur after calling this method may not affect the transaction.

如果您修改的值Current的範圍內發生例外狀況時擲回Dispose呼叫。If you modify the value of Current inside a scope, an exception is thrown when Dispose is called. 不過,在結束範圍時,會還原先前的值。However, at the end of the scope, the previous value is restored. 此外,如果您呼叫DisposeCurrent的交易範圍內,建立交易,交易中止的範圍結尾。In addition, if you call Dispose on Current inside a transaction scope that created the transaction, the transaction aborts at the end of the scope.

建構函式

TransactionScope() TransactionScope() TransactionScope() TransactionScope()

初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class.

TransactionScope(Transaction) TransactionScope(Transaction) TransactionScope(Transaction) TransactionScope(Transaction)

初始化 TransactionScope 類別的新執行個體,並將指定的異動設定為環境異動,以便在範圍內執行的異動式工作使用這個異動。Initializes a new instance of the TransactionScope class and sets the specified transaction as the ambient transaction, so that transactional work done inside the scope uses this transaction.

TransactionScope(Transaction, TimeSpan) TransactionScope(Transaction, TimeSpan) TransactionScope(Transaction, TimeSpan) TransactionScope(Transaction, TimeSpan)

使用指定的逾時值,初始化 TransactionScope 類別的新執行個體,並將指定的異動設定為環境異動,以便在範圍內執行的異動式工作使用這個異動。Initializes a new instance of the TransactionScope class with the specified timeout value, and sets the specified transaction as the ambient transaction, so that transactional work done inside the scope uses this transaction.

TransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption) TransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption) TransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption) TransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption)

使用指定的逾時值和 COM+ 互通性需求,初始化 TransactionScope 類別的新執行個體,並將指定的異動設定為環境異動,以便在範圍內執行的異動式工作使用這個異動。Initializes a new instance of the TransactionScope class with the specified timeout value and COM+ interoperability requirements, and sets the specified transaction as the ambient transaction, so that transactional work done inside the scope uses this transaction.

TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption)

[在 .NET Framework 4.5.1 及更新版本中支援][Supported in the .NET Framework 4.5.1 and later versions] 使用指定的逾時值,初始化 TransactionScope 類別的新執行個體,並將指定的異動設定為環境異動,以便在範圍內執行的異動式工作使用這個異動。Initializes a new instance of the TransactionScope class with the specified timeout value, and sets the specified transaction as the ambient transaction, so that transactional work done inside the scope uses this transaction.

TransactionScope(Transaction, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TransactionScopeAsyncFlowOption) TransactionScope(Transaction, TransactionScopeAsyncFlowOption)

[在 .NET Framework 4.5.1 及更新版本中支援][Supported in the .NET Framework 4.5.1 and later versions] 初始化 TransactionScope 類別的新執行個體,並將指定的異動設定為環境異動,以便在範圍內執行的異動式工作使用這個異動。Initializes a new instance of the TransactionScope class and sets the specified transaction as the ambient transaction, so that transactional work done inside the scope uses this transaction.

TransactionScope(TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeAsyncFlowOption)

使用指定的非同步流程選項,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified asynchronous flow option.

TransactionScope(TransactionScopeOption) TransactionScope(TransactionScopeOption) TransactionScope(TransactionScopeOption) TransactionScope(TransactionScopeOption)

使用指定的需求,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified requirements.

TransactionScope(TransactionScopeOption, TimeSpan) TransactionScope(TransactionScopeOption, TimeSpan) TransactionScope(TransactionScopeOption, TimeSpan) TransactionScope(TransactionScopeOption, TimeSpan)

使用指定的逾時值和需求,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified timeout value and requirements.

TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption)

使用指定的逾時值、需求和非同步流程選項,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified timeout value, requirements, and asynchronous flow option.

TransactionScope(TransactionScopeOption, TransactionOptions) TransactionScope(TransactionScopeOption, TransactionOptions) TransactionScope(TransactionScopeOption, TransactionOptions) TransactionScope(TransactionScopeOption, TransactionOptions)

使用指定的需求,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified requirements.

TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption) TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption) TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption) TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)

使用指定的範圍和 COM+ 互通性需求,以及異動選項,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified scope and COM+ interoperability requirements, and transaction options.

TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)

[在 .NET Framework 4.5.1 及更新版本中支援][Supported in the .NET Framework 4.5.1 and later versions] 使用指定的需求和非同步流程選項,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified requirements and asynchronous flow option.

TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption) TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)

使用指定的需求和非同步流程選項,初始化 TransactionScope 類別的新執行個體。Initializes a new instance of the TransactionScope class with the specified requirements and asynchronous flow option.

方法

Complete() Complete() Complete() Complete()

表示範圍內的所有作業都已成功完成。Indicates that all operations within the scope are completed successfully.

Dispose() Dispose() Dispose() Dispose()

結束交易範圍。Ends the transaction scope.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

判斷指定的物件是否等於目前的物件。Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

做為預設雜湊函式。Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

取得目前執行個體的 TypeGets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

建立目前 Object 的淺層複本 (Shallow Copy)。Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

傳回代表目前物件的字串。Returns a string that represents the current object.

(Inherited from Object)

適用於

執行緒安全性

此型別具備執行緒安全。This type is thread safe.

另請參閱