Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe TransactionScope

Faz um bloco de código transacional. Esta classe não pode ser herdada.

System.Object
  System.Transactions.TransactionScope

Namespace:  System.Transactions
Assembly:  System.Transactions (em System.Transactions.dll)

public sealed class TransactionScope : IDisposable

O tipo TransactionScope expõe os membros a seguir.

  NomeDescrição
Método públicoTransactionScope()Inicializa uma nova instância da classe TransactionScope.
Método públicoTransactionScope(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 dentro do escopo usa essa transação.
Método públicoTransactionScope(TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope com a opção assíncrono especificada de fluxo.
Método públicoTransactionScope(TransactionScopeOption)Inicializa uma nova instância da classe TransactionScope com os requisitos específicos.
Método públicoTransactionScope(Transaction, TimeSpan)Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite especificado, e defina a transação especificada como a transação ambiente, para que o trabalho feito transacional dentro do escopo use esta transação.
Método públicoTransactionScope(Transaction, TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope e defina a transação especificada como a transação ambiente, para que o trabalho feito transacional dentro do escopo use esta transação.
Método públicoTransactionScope(TransactionScopeOption, TimeSpan)Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite e os requisitos específicos.
Método públicoTransactionScope(TransactionScopeOption, TransactionOptions)Inicializa uma nova instância da classe TransactionScope com os requisitos específicos.
Método públicoTransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope com os requisitos especificados e o padrão assíncrono de fluxo.
Método públicoTransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption)Inicializa uma nova instância da classe TransactionScope com os requisitos específicos de valor de tempo limite e interoperabilidade com +, e defina a transação especificada como a transação ambiente, para que o trabalho feito transacional dentro do escopo use esta transação.
Método públicoTransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite especificado, e defina a transação especificada como a transação ambiente, para que o trabalho feito transacional dentro do escopo use esta transação.
Método públicoTransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope com o valor de tempo limite especificado, os requisitos, e a opção assíncrona de fluxo.
Método públicoTransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)Inicializa uma nova instância da classe TransactionScope com os requisitos específicos de escopo e interoperabilidade com +, e opções de transação.
Método públicoTransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)[Suportado no .NET Framework 4.5.1 somente] Inicializa uma nova instância da classe TransactionScope com os requisitos especificados e o padrão assíncrono de fluxo.
Superior

  NomeDescrição
Método públicoCompleteIndica que todas as operações dentro do escopo estão concluídas com êxito.
Método públicoDisposeFinaliza o escopo de transação.
Método públicoEquals(Object) Verifica se o objeto especificado é igual ao objeto atual. (Herdado de Object.)
Método públicoGetHashCodeServe como a função de hash padrão. (Herdado de Object.)
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método públicoToStringRetorna uma string que representa o objeto atual. (Herdado de Object.)
Superior

A infra-estrutura do System.Transactions fornece tanto um modelo de programação explícito baseado na classe Transaction bem como um modelo de programação implícito usando a classe TransactionScope, na qual as transações são automaticamente gerenciadas pela infra-estrutura.

Observação importanteImportante

É recomendável que você crie transações implícitas usando a classe TransactionScope, para que o contexto da transação do ambiente seja gerenciado automaticamente para você. Você também deve usar TransactionScope e a classe de DependentTransaction para aplicativos que requerem o uso da mesma transação por várias chamadas de função ou de vários threads chama. Para obter mais informações sobre este modelo, consulte o tópico de Implementing An Implicit Transaction Using Transaction Scope . Para obter mais informações sobre a escrever um aplicativo transacional, consulte Writing A Transactional Application.

Em cima de criar uma instância TransactionScope pela instrução de new , o gerenciador de transações determina que a transação participar. Uma vez que determinado escopo, sempre participa na transação. A decisão é baseada em dois fatores: se uma transação ambiente estiver presente e o valor do parâmetro de TransactionScopeOption no construtor. A transação ambiente é a transação que executa o código dentro. Você pode obter uma referência à transação ambiente chamando a propriedade estática de Current da classe de Transaction . Para obter mais informações sobre como esse parâmetro é usado, por favor consulte a seção de gerenciamento de fluxo transação” do tópico de Implementing An Implicit Transaction Using Transaction Scope .

Se nenhuma exceção ocorre no escopo de transação (isto é, entre a inicialização de objeto de TransactionScope e a chamada do método de Dispose ), então a transação em que o escopo participa é reservado continuar. Se ocorrer uma exceção dentro do escopo de transação, a transação em que participa será revertida.

Quando seu aplicativo concluir qualquer trabalho que deseja executar em uma transação, você deve chamar o método de Complete apenas uma vez para informar o gerenciador de transações que é aceitável confirmar a transação. Falhar para chamar esse método anula a transação.

Uma chamada para o método de Dispose marca o final do escopo de transação. Exceções que ocorrem após chamar este método não pode afetar a transação.

Se você alterar o valor de Current em um escopo, uma exceção será lançada quando Dispose é chamado. Entretanto, no final do escopo, o valor anterior é restaurado. Além disso, se você chamar Dispose em Current em um escopo de transação que cria a transação, a transação nulos no final do escopo.

O exemplo a seguir demonstra como usar a classe de TransactionScope para definir um bloco de código para participar em 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);
    }
    catch (ApplicationException ex)
    {
        writer.WriteLine("ApplicationException Message: {0}", ex.Message);
    }

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

    return returnValue;
}


.NET Framework

Com suporte em: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Esse tipo é de Thread de segurança.

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2015 Microsoft