TransactionScope.Dispose Méthode

Définition

Termine la portée de transaction.Ends the transaction scope.

public:
 virtual void Dispose();
public void Dispose ();
abstract member Dispose : unit -> unit
override this.Dispose : unit -> unit
Public Sub Dispose ()

Implémente

Exemples

L’exemple suivant montre comment utiliser la classe TransactionScope pour définir un bloc de code qui participe à une transaction.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

Remarques

L’appel de cette méthode marque la fin de la portée de la transaction.Calling this method marks the end of the transaction scope. Si l’objet TransactionScope a créé la transaction et Complete a été appelée sur l’étendue, l’objet TransactionScope tente de valider la transaction lorsque cette méthode est appelée.If the TransactionScope object created the transaction and Complete was called on the scope, the TransactionScope object attempts to commit the transaction when this method is called. Dans ce cas, cette méthode se bloque jusqu’à ce que la première phase du traitement de la transaction soit terminée.In this case, this method blocks until the first phase of transaction processing is complete. La première phase se termine une fois que tous les gestionnaires de ressources et les inscriptions de la transaction ont voté sur le résultat de la transaction et que la TransactionManager a durablement décidé de valider ou d’abandonner la transaction.The first phase ends after all resource managers and enlistments in the transaction have voted on the transaction outcome and the TransactionManager has durably decided to commit or abort the transaction. La deuxième phase de traitement est toujours asynchrone.The second phase of processing is always asynchronous. Par conséquent, il n’existe aucune garantie que les données simplement validées à partir d’une transaction donnée soient immédiatement disponibles par la suite quand vous n’utilisez pas une autre transaction pour afficher ces données.Therefore, there is no guarantee that data just committed from within a given transaction will be immediately available afterwards when not using another transaction to view this data.

L’utilisation de la C# construction using garantit que cette méthode est appelée même si une exception se produit.The use of the C# using construction ensures that this method is called even if an exception occurs. Il est possible que les exceptions qui se produisent après l’appel à cette méthode n’affectent pas la transaction.Exceptions that occur after calling this method may not affect the transaction. Cette méthode restaure également la transaction ambiante à son état d’origine.This method also restores the ambient transaction to it original state. Une TransactionAbortedException est levée si la transaction n’est pas réellement validée.A TransactionAbortedException is thrown if the transaction is not actually committed.

Étant donné que cette méthode bloque jusqu’à ce que la première phase du traitement de la transaction soit terminée, vous devez être extrêmement prudent lors de l’utilisation de cette méthode dans une application Windows Form (WinForm), ou un blocage peut se produire.Because this method blocks until the first phase of transaction processing is complete, you should be extremely careful when using this method in a Windows Form (WinForm) application, or a deadlock can occur. Si vous appelez cette méthode dans un événement de contrôle WinForm (par exemple, en cliquant sur un bouton) et que vous utilisez la méthode synchrone Invoke pour demander au contrôle d’effectuer des tâches d’interface utilisateur (par exemple, modifier des couleurs) au milieu du traitement de la transaction, un blocage se produit.If you call this method inside one WinForm Control event (for example, clicking a button), and use the synchronous Invoke method to direct the control to perform some UI tasks (for example, changing colors) in the middle of processing the transaction, a deadlock will happen. Cela est dû au fait que la méthode Invoke est synchrone et bloque le thread de travail jusqu’à ce que le thread d’interface utilisateur termine son travail.This is because the Invoke method is synchronous and blocks the worker thread until the UI thread finishes its job. Toutefois, dans notre scénario, le thread d’interface utilisateur attend également que le thread de travail valide la transaction.However, in our scenario, the UI thread is also waiting for the worker thread to commit the transaction. Le résultat est qu’aucun ne peut continuer et que l’étendue attend indéfiniment que la validation se termine.The result is that none is able to proceed and the scope waits indefinitely for the Commit to finish. Vous devez utiliser BeginInvoke plutôt que Invoke dans la mesure du possible, car elle est asynchrone et donc moins sujette aux verrous mortels.You should use BeginInvoke rather than Invoke wherever possible, because it is asynchronous and thus less prone to deadlock.

Pour plus d’informations sur l’utilisation de cette méthode, consultez la rubrique implémentation d’une transaction implicite à l’aide d’une étendue de transaction .For more information on how this method is used, see the Implementing An Implicit Transaction Using Transaction Scope topic.

S’applique à

Voir aussi