TransactionScope-Klasse

TransactionScope-Klasse

Ändert einen Codeblock in transaktional. Diese Klasse kann nicht geerbt werden.

Namespace: System.Transactions
Assembly: System.Transactions (in system.transactions.dll)

public sealed class TransactionScope : IDisposable
public final class TransactionScope implements IDisposable
public final class TransactionScope implements IDisposable
Nicht zutreffend.

Die System.Transactions-Infrastruktur bietet sowohl ein explizites Programmiermodell, das auf der Transaction-Klasse basiert, als auch ein implizites Programmiermodell, das die TransactionScope-Klasse verwendet, in der Transaktionen automatisch von der Infrastruktur verwaltet werden.

HinweisWichtig:

Es empfiehlt sich, unter Verwendung der TransactionScope-Klasse implizite Transaktionen zu erstellen, damit der umgebende Transaktionskontext automatisch für Sie verwaltet wird. Ebenso sollten Sie die TransactionScope-Klasse und die DependentTransaction-Klasse für Anwendungen verwenden, bei denen dieselbe Transaktion über mehrere Funktionsaufrufe oder mehrere Threadaufrufe hinweg verwendet werden muss. Weitere Informationen über dieses Modell finden Sie im Thema Implementieren einer impliziten Transaktion mithilfe eines Transaktionsbereichs. Weitere Informationen über das Schreiben einer Transaktionsanwendung finden Sie unter Schreiben einer Transaktionsanwendung.

Bei der Instanziierung eines TransactionScope durch die new-Anweisung bestimmt der Transaktions-Manager, an welcher Transaktion der Bereich beteiligt sein soll. Wenn der Bereich festgelegt ist, ist er immer an dieser Transaktion beteiligt. Die Entscheidung hängt von zwei Faktoren ab: vom Vorhandensein einer umgebenden Transaktion und vom Wert des TransactionScopeOption-Parameters im Konstruktor. Die umgebende Transaktion ist die Transaktion, in der der Code ausgeführt wird. Einen Verweis auf die umgebende Transaktion können Sie durch Abrufen der statischen Current-Eigenschaft der Transaction-Klasse abrufen. Weitere Informationen über das Verwenden dieses Parameters finden Sie im Abschnitt "Verwalten des Transaktionsflusses" im Thema Implementieren einer impliziten Transaktion mithilfe eines Transaktionsbereichs.

Wenn im Transaktionsbereich (d. h. zwischen der Initialisierung des TransactionScope-Objekts und dem Aufruf der zugehörigen Dispose-Methode) keine Ausnahme ausgelöst wird, kann die Transaktion, an der der Bereich beteiligt ist, fortgesetzt werden. Wenn innerhalb des Transaktionsbereichs eine Ausnahme ausgelöst wird, wird für die Transaktion, an der der Transaktionsbereich beteiligt ist, ein Rollback ausgeführt.

Wenn die Anwendung alle in einer Transaktion auszuführenden Arbeiten abschließt, sollten Sie die Complete-Methode nur einmal aufrufen, um den Transaktions-Manager zu benachrichtigen, dass für die Transaktion ein Commit ausgeführt werden kann. Wenn diese Methode nicht aufgerufen wird, wird die Transaktion abgebrochen.

Ein Aufruf der Dispose-Methode markiert das Ende des Transaktionsbereichs. Ausnahmen, die nach dem Aufrufen dieser Methode eintreten, beeinflussen die Transaktion möglicherweise nicht.

Wenn Sie den Wert von Current innerhalb eines Bereichs ändern, wird beim Aufrufen von Dispose eine Ausnahme ausgelöst. Am Ende des Bereichs wird der vorherige Wert jedoch wiederhergestellt. Außerdem wird die Transaktion am Ende des Bereichs abgebrochen, wenn Sie Dispose für Current innerhalb des Transaktionsbereichs aufrufen, der die Transaktion erstellt hat.

Im folgenden Beispiel wird veranschaulicht, wie mithilfe der TransactionScope-Klasse ein Codeblock für die Beteiligung an der Transaktion definiert wird.

// 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();

    // 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))
        {
            try
            {
                // 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))
                    try
                    {
                        // 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);
                    }
                    catch (Exception ex)
                    {
                        // Display information that command2 failed.
                        writer.WriteLine("returnValue for command2: {0}", returnValue);
                        writer.WriteLine("Exception Message2: {0}", ex.Message);
                    }
            }
            catch (Exception ex)
            {
                // Display information that command1 failed.
                writer.WriteLine("returnValue for command1: {0}", returnValue);
                writer.WriteLine("Exception Message1: {0}", ex.Message);
            }
        }

        // The Complete method commits the transaction. If an exception has been thrown,
        // Complete is not  called and the transaction is rolled back.
        scope.Complete();
    }

    // The returnValue is greater than 0 if the transaction committed.
    if (returnValue > 0)
    {
        writer.WriteLine("Transaction was committed.");
    }
    else
    {
        // You could write additional business logic here, for example, you can notify the caller 
        // by throwing a TransactionAbortedException, or logging the failure.
        writer.WriteLine("Transaction rolled back.");
    }

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

    return returnValue;
}

System.Object
  System.Transactions.TransactionScope

Dieser Typ ist threadsicher.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 wird unter Windows Vista, Microsoft Windows XP SP2 und Windows Server 2003 SP1 unterstützt.

.NET Framework

Unterstützt in: 3.0, 2.0
Anzeigen:
© 2016 Microsoft