TransactionScope Classe

Definição

Torna um bloco de códigos transacional.Makes a code block transactional. Essa classe não pode ser herdada.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
Herança
TransactionScope
Implementações

Exemplos

O exemplo a seguir demonstra como usar a TransactionScope classe para definir um bloco de código para participar de uma transação.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

Comentários

A System.Transactions infraestrutura fornece um modelo de programação explícito baseado Transaction na classe, bem como um modelo de programação implícito usando a TransactionScope classe, na qual as transações são gerenciadas automaticamente pela infraestrutura.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.

Importante

É recomendável que você crie transações implícitas TransactionScope usando a classe, para que o contexto de transação de ambiente seja automaticamente gerenciado para você.We recommend that you create implicit transactions using the TransactionScope class, so that the ambient transaction context is automatically managed for you. Você também deve usar a TransactionScope classe DependentTransaction e para aplicativos que exigem o uso da mesma transação em várias chamadas de função ou em várias chamadas de thread.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. Para obter mais informações sobre esse modelo, consulte o tópico implementando uma transação implícita usando escopo de transação .For more information on this model, see the Implementing An Implicit Transaction Using Transaction Scope topic. Para obter mais informações sobre como escrever um aplicativo transacional, consulte escrevendo um aplicativo transacional.For more information on writing a transactional application, see Writing A Transactional Application.

Ao instanciar um TransactionScope new pela instrução, o Gerenciador de transações determina em qual transação participar.Upon instantiating a TransactionScope by the new statement, the transaction manager determines which transaction to participate in. Uma vez determinado, o escopo sempre participa dessa transação.Once determined, the scope always participates in that transaction. A decisão se baseia em dois fatores: se houver uma transação de ambiente e o valor de TransactionScopeOption parâmetro no construtor.The decision is based on two factors: whether an ambient transaction is present and the value of the TransactionScopeOption parameter in the constructor. A transação de ambiente é a transação em que seu código é executado.The ambient transaction is the transaction your code executes in. Você pode obter uma referência para a transação de ambiente chamando estático Transaction.Current propriedade o Transaction classe.You can obtain a reference to the ambient transaction by calling the static Transaction.Current property of the Transaction class. Para obter mais informações sobre como esse parâmetro é usado, consulte a seção "gerenciamento de fluxo de transações" do tópico implementando uma transação implícita usando escopo de transação .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.

Se nenhuma exceção ocorrer dentro do escopo da transação (ou seja, entre a inicialização do TransactionScope objeto e a chamada de seu Dispose método), a transação na qual o escopo participará pode continuar.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. Se ocorrer uma exceção dentro do escopo da transação, a transação na qual ela participar será revertida.If an exception does occur within the transaction scope, the transaction in which it participates will be rolled back.

Quando o aplicativo concluir todo o trabalho que deseja executar em uma transação, você deverá chamar o Complete método apenas uma vez para informar o Gerenciador de transações de que é aceitável confirmar a transação.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. A falha ao chamar esse método anula a transação.Failing to call this method aborts the transaction.

Uma chamada para o Dispose método marca o final do escopo da transação.A call to the Dispose method marks the end of the transaction scope. Exceções que ocorrem depois de chamar esse método não podem afetar a transação.Exceptions that occur after calling this method may not affect the transaction.

Se você modificar o valor de Current dentro de um escopo, uma exceção será lançada Dispose quando for chamado.If you modify the value of Current inside a scope, an exception is thrown when Dispose is called. No entanto, no final do escopo, o valor anterior é restaurado.However, at the end of the scope, the previous value is restored. Além disso, se você chamar Dispose on Current dentro de um escopo de transação que criou a transação, a transação será anulada no final do escopo.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.

Construtores

TransactionScope()

Inicializa uma nova instância da classe TransactionScope.Initializes a new instance of the TransactionScope class.

TransactionScope(Transaction)

Inicializa uma nova instância da classe TransactionScope e define a transação especificada como a transação de ambiente, de modo que o trabalho transacional realizado dentro do escopo use essa transação.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)

Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite especificado e define a transação especificada como a transação de ambiente, de modo que o trabalho transacional realizado dentro do escopo use essa transação.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)

Inicializa uma nova instância da classe TransactionScope com os requisitos de interoperabilidade COM+ e o valor de tempo limite especificados e define a transação especificada como a transação de ambiente, de modo que o trabalho transacional realizado dentro do escopo use essa transação.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)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores][Supported in the .NET Framework 4.5.1 and later versions] Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite especificado e define a transação especificada como a transação de ambiente, de modo que o trabalho transacional realizado dentro do escopo use essa transação.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)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores][Supported in the .NET Framework 4.5.1 and later versions] Inicializa uma nova instância da classe TransactionScope e define a transação especificada como a transação de ambiente, de modo que o trabalho transacional realizado dentro do escopo use essa transação.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)

Inicializa uma nova instância da classe TransactionScope com a opção de fluxo assíncrono especificado.Initializes a new instance of the TransactionScope class with the specified asynchronous flow option.

TransactionScope(TransactionScopeOption)

Inicializa uma nova instância da classe TransactionScope com os requisitos especificados.Initializes a new instance of the TransactionScope class with the specified requirements.

TransactionScope(TransactionScopeOption, TimeSpan)

Inicializa uma nova instância da classe TransactionScope com o valor e requisitos de tempo limite especificados.Initializes a new instance of the TransactionScope class with the specified timeout value and requirements.

TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption)

Inicializa uma nova instância da classe TransactionScope com os requisitos e a opção de fluxo assíncrono, bem como o valor de tempo limite especificados.Initializes a new instance of the TransactionScope class with the specified timeout value, requirements, and asynchronous flow option.

TransactionScope(TransactionScopeOption, TransactionOptions)

Inicializa uma nova instância da classe TransactionScope com os requisitos especificados.Initializes a new instance of the TransactionScope class with the specified requirements.

TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)

Inicializa uma nova instância da classe TransactionScope com o escopo especificado e os requisitos de interoperabilidade COM+ e opções de transação.Initializes a new instance of the TransactionScope class with the specified scope and COM+ interoperability requirements, and transaction options.

TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores][Supported in the .NET Framework 4.5.1 and later versions] Inicializa uma nova instância da classe TransactionScope com os requisitos e a opção de fluxo assíncrono especificados.Initializes a new instance of the TransactionScope class with the specified requirements and asynchronous flow option.

TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)

Inicializa uma nova instância da classe TransactionScope com os requisitos e a opção de fluxo assíncrono especificados.Initializes a new instance of the TransactionScope class with the specified requirements and asynchronous flow option.

Métodos

Complete()

Indica que todas as operações dentro do escopo foram concluídas com êxito.Indicates that all operations within the scope are completed successfully.

Dispose()

Encerra o escopo da transação.Ends the transaction scope.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também