Ler em inglês

Compartilhar via


TransactionScope Classe

Definição

Torna um bloco de códigos transacional. Essa classe não pode ser herdada.

public sealed class TransactionScope : IDisposable
[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public sealed class TransactionScope : IDisposable
Herança
TransactionScope
Atributos
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.

// 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;
}

Comentários

A System.Transactions infraestrutura fornece um modelo de programação explícito com base na Transaction classe , bem como um modelo de programação implícita usando a classe , no qual as TransactionScope transações são gerenciadas automaticamente pela infraestrutura.

Importante

Recomendamos que você crie transações implícitas usando a TransactionScope classe para que o contexto de transação ambiente seja gerenciado automaticamente para você. Você também deve usar a TransactionScope classe e DependentTransaction para aplicativos que exigem o uso da mesma transação em várias chamadas de função ou várias chamadas de thread. Para obter mais informações sobre esse modelo, consulte o tópico Implementando uma transação implícita usando escopo de transação . Para obter mais informações sobre como escrever um aplicativo transacional, consulte Gravando um aplicativo transacional.

Ao instanciar um TransactionScope pela instrução , o new gerenciador de transações determina em qual transação participar. Uma vez determinado, o escopo sempre participa dessa transação. A decisão se baseia em dois fatores: se houver uma transação de ambiente e o valor de TransactionScopeOption parâmetro no construtor. A transação de ambiente é a transação em que seu código é executado. Você pode obter uma referência para a transação de ambiente chamando estático Transaction.Current propriedade o Transaction classe. Para obter mais informações sobre como esse parâmetro é usado, consulte a seção "Gerenciamento de Fluxo de Transação" do tópico Implementando uma transação implícita usando escopo de transação .

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 participa terá permissão para prosseguir. Se ocorrer uma exceção dentro do escopo da transação, a transação na qual ela participa será revertida.

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 ao gerenciador de transações que é aceitável confirmar a transação. A falha ao chamar esse método anula a transação.

Uma chamada para o Dispose método marca o final do escopo da transação. Exceções que ocorrem depois de chamar esse método não podem afetar a transação.

Se você modificar o valor de dentro de Current um escopo, uma exceção será gerada quando Dispose for chamada. No entanto, no final do escopo, o valor anterior é restaurado. Além disso, se você chamar Dispose dentro Current de um escopo de transação que criou a transação, a transação será anulada no final do escopo.

Construtores

TransactionScope()

Inicializa uma nova instância da classe TransactionScope.

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.

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.

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.

TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores]

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.

TransactionScope(Transaction, TransactionScopeAsyncFlowOption)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores]

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.

TransactionScope(TransactionScopeAsyncFlowOption)

Inicializa uma nova instância da classe TransactionScope com a opção de fluxo assíncrono especificado.

TransactionScope(TransactionScopeOption)

Inicializa uma nova instância da classe TransactionScope com os requisitos especificados.

TransactionScope(TransactionScopeOption, TimeSpan)

Inicializa uma nova instância da classe TransactionScope com o valor e requisitos de tempo limite especificados.

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.

TransactionScope(TransactionScopeOption, TransactionOptions)

Inicializa uma nova instância da classe TransactionScope com os requisitos especificados.

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.

TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)

[Suporte somente no .NET Framework 4.5.1 e versões posteriores]

Inicializa uma nova instância da classe TransactionScope com os requisitos e a opção de fluxo assíncrono especificados.

TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)

Inicializa uma nova instância da classe TransactionScope com os requisitos e a opção de fluxo assíncrono especificados.

Métodos

Complete()

Indica que todas as operações dentro do escopo foram concluídas com êxito.

Dispose()

Encerra o escopo da transação.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a

Produto Versões
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

Acesso thread-safe

Este tipo é thread-safe.

Confira também