TransactionScope Klasa

Odwołanie

Definicja

Przestrzeń nazw:: System.Transactions

Zestaw:: System.Transactions.Local.dll

Zestaw:: System.Transactions.dll

Zestaw:: netstandard.dll

Źródło:: TransactionScope.cs

Źródło:: TransactionScope.cs

Źródło:: TransactionScope.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Tworzy blok kodu transakcyjny. Klasa ta nie może być dziedziczona.

public ref class TransactionScope sealed : IDisposable

public sealed class TransactionScope : IDisposable

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

type TransactionScope = class
    interface IDisposable

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

Public NotInheritable Class TransactionScope
Implements IDisposable

Dziedziczenie: Object
TransactionScope

Atrybuty: UnsupportedOSPlatformAttribute

Implementuje: IDisposable

Przykłady

W poniższym przykładzie pokazano, jak używać TransactionScope klasy do definiowania bloku kodu do uczestnictwa w transakcji.

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

Uwagi

Infrastruktura System.Transactions zapewnia zarówno jawny model programowania oparty na Transaction klasie, jak i niejawny model programowania przy użyciu TransactionScope klasy , w której transakcje są automatycznie zarządzane przez infrastrukturę.

Ważne

Zalecamy tworzenie niejawnych transakcji przy użyciu TransactionScope klasy , dzięki czemu kontekst transakcji otoczenia jest automatycznie zarządzany. Należy również użyć TransactionScope klasy i DependentTransaction dla aplikacji, które wymagają użycia tej samej transakcji w wielu wywołaniach funkcji lub wielu wywołań wątku. Aby uzyskać więcej informacji na temat tego modelu, zobacz temat Implementowanie niejawnej transakcji przy użyciu zakresu transakcji . Aby uzyskać więcej informacji na temat pisania aplikacji transakcyjnej, zobacz Pisanie aplikacji transakcyjnej.

Po utworzeniu TransactionScope wystąpienia przez instrukcję new menedżer transakcji określa, w której transakcji należy uczestniczyć. Po określeniu zakresu zawsze uczestniczy w danej transakcji. Decyzja opiera się na dwa czynniki: Określa, czy transakcja otoczenia jest obecny i ma wartość TransactionScopeOption parametr w konstruktorze. Otoczenia transakcji to transakcja wykonywana w kodzie. Odwołanie do transakcji otoczenia można uzyskać przez wywołanie metody statyczne klasy Transaction.Current właściwości Transaction klasy. Aby uzyskać więcej informacji na temat sposobu używania tego parametru, zobacz sekcję "Zarządzanie przepływem transakcji" w temacie Implementowanie niejawnej transakcji przy użyciu zakresu transakcji .

Jeśli żaden wyjątek nie występuje w zakresie transakcji (czyli między inicjowaniem TransactionScope obiektu a wywołaniem jego Dispose metody), transakcja, w której zakres uczestniczy, może kontynuować. Jeśli wyjątek wystąpi w zakresie transakcji, transakcja, w której uczestniczy, zostanie wycofana.

Gdy aplikacja zakończy całą pracę, którą chce wykonać w transakcji, należy wywołać Complete metodę tylko raz, aby poinformować menedżera transakcji, że można zatwierdzić transakcję. Nie można wywołać tej metody przerywa transakcję.

Wywołanie Dispose metody oznacza koniec zakresu transakcji. Wyjątki, które mogą występować po wywołaniu tej metody nie może mieć wpływ na transakcji.

Jeśli zmodyfikujesz wartość Current wewnątrz zakresu, podczas wywoływanego wyjątku zostanie zgłoszony Dispose wyjątek. Jednak na końcu zakresu zostanie przywrócona poprzednia wartość. Ponadto w przypadku wywołania Dispose Current wewnątrz zakresu transakcji, który utworzył transakcję, transakcja przerywa na końcu zakresu.

Konstruktory

TransactionScope()	Inicjuje nowe wystąpienie klasy TransactionScope.
TransactionScope(Transaction)	Inicjuje TransactionScope nowe wystąpienie klasy i ustawia określoną transakcję jako transakcję otoczenia, tak aby praca transakcyjna wykonywana wewnątrz zakresu używa tej transakcji.
TransactionScope(Transaction, TimeSpan)	Inicjuje nowe wystąpienie TransactionScope klasy z określoną wartością limitu czasu i ustawia określoną transakcję jako otoczenia transakcji, tak aby praca transakcyjna wykonywana wewnątrz zakresu używa tej transakcji.
TransactionScope(Transaction, TimeSpan, EnterpriseServicesInteropOption)	Inicjuje nowe wystąpienie TransactionScope klasy z określoną wartością limitu czasu i wymaganiami współdziałania COM+ i ustawia określoną transakcję jako transakcję otoczenia, tak aby praca transakcyjna wykonywana wewnątrz zakresu używa tej transakcji.
TransactionScope(Transaction, TimeSpan, TransactionScopeAsyncFlowOption)	[Obsługiwane w .NET Framework 4.5.1 i nowszych wersjach] Inicjuje nowe wystąpienie TransactionScope klasy z określoną wartością limitu czasu i ustawia określoną transakcję jako otoczenia transakcji, tak aby praca transakcyjna wykonywana wewnątrz zakresu używa tej transakcji.
TransactionScope(Transaction, TransactionScopeAsyncFlowOption)	[Obsługiwane w .NET Framework 4.5.1 i nowszych wersjach] Inicjuje TransactionScope nowe wystąpienie klasy i ustawia określoną transakcję jako transakcję otoczenia, tak aby praca transakcyjna wykonywana wewnątrz zakresu używa tej transakcji.
TransactionScope(TransactionScopeAsyncFlowOption)	Inicjuje TransactionScope nowe wystąpienie klasy z określoną opcją przepływu asynchronicznego.
TransactionScope(TransactionScopeOption)	Inicjuje TransactionScope nowe wystąpienie klasy z określonymi wymaganiami.
TransactionScope(TransactionScopeOption, TimeSpan)	Inicjuje TransactionScope nowe wystąpienie klasy z określoną wartością limitu czasu i wymaganiami.
TransactionScope(TransactionScopeOption, TimeSpan, TransactionScopeAsyncFlowOption)	Inicjuje nowe wystąpienie TransactionScope klasy z określoną wartością limitu czasu, wymaganiami i opcją przepływu asynchronicznego.
TransactionScope(TransactionScopeOption, TransactionOptions)	Inicjuje TransactionScope nowe wystąpienie klasy z określonymi wymaganiami.
TransactionScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)	Inicjuje TransactionScope nowe wystąpienie klasy z określonym zakresem i wymaganiami dotyczącymi współdziałania MODELU COM+ oraz opcjami transakcji.
TransactionScope(TransactionScopeOption, TransactionOptions, TransactionScopeAsyncFlowOption)	[Obsługiwane w .NET Framework 4.5.1 i nowszych wersjach] Inicjuje TransactionScope nowe wystąpienie klasy z określonymi wymaganiami i opcją przepływu asynchronicznego.
TransactionScope(TransactionScopeOption, TransactionScopeAsyncFlowOption)	Inicjuje TransactionScope nowe wystąpienie klasy z określonymi wymaganiami i opcją przepływu asynchronicznego.

Metody

Complete()	Wskazuje, że wszystkie operacje w zakresie zostały ukończone pomyślnie.
Dispose()	Kończy zakres transakcji.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.

Zobacz też

Implementowanie niejawnej transakcji przy użyciu zakresu transakcji