TransactionScope Classe

Definição

Namespace:

System.Transactions

Assembly:

System.Transactions.Local.dll

Origem:

TransactionScope.cs

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

public ref class TransactionScope sealed : IDisposable

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public sealed class TransactionScope : IDisposable

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
type TransactionScope = class
    interface IDisposable

Public NotInheritable Class TransactionScope
Implements IDisposable

Herança

Object

TransactionScope

Atributos

UnsupportedOSPlatformAttribute

Implementações

IDisposable

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

'  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 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)

Acesso thread-safe

Este tipo é thread-safe.

Confira também

• Implementando uma transação implícita usando o escopo da transação