TransactionScope.Dispose Methode

public:
 virtual void Dispose();

public void Dispose();

abstract member Dispose : unit -> unit
override this.Dispose : unit -> unit

Public Sub Dispose ()

Implementeringen

Voorbeelden

In het volgende voorbeeld ziet u hoe u de TransactionScope klasse gebruikt om een codeblok te definiëren om deel te nemen aan een transactie.

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

Opmerkingen

Als u deze methode aanroept, wordt het einde van het transactiebereik gemarkeerd. Als het TransactionScope object de transactie heeft gemaakt en Complete werd aangeroepen in het bereik, probeert het TransactionScope object de transactie door te voeren wanneer deze methode wordt aangeroepen. In dit geval wordt deze methode geblokkeerd totdat de eerste fase van transactieverwerking is voltooid. De eerste fase eindigt nadat alle resourcemanagers en inlistingen in de transactie hebben gestemd over het transactieresultaat en het TransactionManager heeft definitief besloten om de transactie vast te leggen of af te breken. De tweede fase van de verwerking is altijd asynchroon. Daarom is er geen garantie dat gegevens die alleen vanuit een bepaalde transactie zijn vastgelegd, onmiddellijk daarna beschikbaar zijn wanneer ze geen andere transactie gebruiken om deze gegevens weer te geven.

Het gebruik van de C# using -constructie zorgt ervoor dat deze methode wordt aangeroepen, zelfs als er een uitzondering optreedt. Uitzonderingen die optreden na het aanroepen van deze methode, hebben mogelijk geen invloed op de transactie. Deze methode herstelt ook de omgevingstransactie naar de oorspronkelijke staat. Er wordt een TransactionAbortedException gegenereerd als de transactie niet daadwerkelijk wordt doorgevoerd.

Omdat deze methode wordt geblokkeerd totdat de eerste fase van transactieverwerking is voltooid, moet u uiterst voorzichtig zijn bij het gebruik van deze methode in een Windows Formulier-toepassing (WinForm) of kan er een impasse optreden. Als u deze methode aanroept binnen één WinForm-besturingselementgebeurtenis (bijvoorbeeld op een knop klikken) en de synchrone Invoke methode gebruikt om het besturingselement te leiden om bepaalde UI-taken uit te voeren (bijvoorbeeld kleuren wijzigen) in het midden van de verwerking van de transactie, gebeurt er een impasse. Dit komt doordat de Invoke methode synchroon is en de werkrolthread blokkeert totdat de ui-thread de taak heeft voltooid. In ons scenario wacht de UI-thread echter ook totdat de werkrolthread de transactie doorvoert. Het resultaat is dat er geen kan worden voortgezet en dat het bereik voor onbepaalde tijd wacht totdat de doorvoer is voltooid. U moet BeginInvoke gebruiken in plaats Invoke van waar mogelijk, omdat het asynchroon is en dus minder gevoelig is voor impasses.

Zie het onderwerp Een impliciete transactie implementeren met transactiebereik voor meer informatie over hoe deze methode wordt gebruikt.

Zie ook

• Een impliciete transactie implementeren met behulp van transactiebereik