DependentTransaction Classe

Definizione

Descrive un duplicato di una transazione che garantisce che non può essere eseguito il commit della transazione fino a quando nell'applicazione non si completano le operazioni relative alla transazione.Describes a clone of a transaction providing guarantee that the transaction cannot be committed until the application comes to rest regarding work on the transaction. La classe non può essere ereditata.This class cannot be inherited.

public ref class DependentTransaction sealed : System::Transactions::Transaction
public ref class DependentTransaction sealed : System::Transactions::Transaction, System::Runtime::Serialization::ISerializable
public sealed class DependentTransaction : System.Transactions.Transaction
[System.Serializable]
public sealed class DependentTransaction : System.Transactions.Transaction
[System.Serializable]
public sealed class DependentTransaction : System.Transactions.Transaction, System.Runtime.Serialization.ISerializable
type DependentTransaction = class
    inherit Transaction
[<System.Serializable>]
type DependentTransaction = class
    inherit Transaction
[<System.Serializable>]
type DependentTransaction = class
    inherit Transaction
    interface ISerializable
Public NotInheritable Class DependentTransaction
Inherits Transaction
Public NotInheritable Class DependentTransaction
Inherits Transaction
Implements ISerializable
Ereditarietà
DependentTransaction
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come creare una transazione dipendente.The following example shows you how to create a dependent transaction.

static void Main(string[] args)
{
    try
    {
        using (TransactionScope scope = new TransactionScope())
        {
            // Perform transactional work here.

            //Queue work item
            ThreadPool.QueueUserWorkItem(new WaitCallback(WorkerThread), Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete));

            //Display transaction information
            Console.WriteLine("Transaction information:");
            Console.WriteLine("ID:             {0}", Transaction.Current.TransactionInformation.LocalIdentifier);
            Console.WriteLine("status:         {0}", Transaction.Current.TransactionInformation.Status);
            Console.WriteLine("isolationlevel: {0}", Transaction.Current.IsolationLevel);

            //Call Complete on the TransactionScope based on console input
            ConsoleKeyInfo c;
            while (true)
            {
                            Console.Write("Complete the transaction scope? [Y|N] ");
                c = Console.ReadKey();
                Console.WriteLine();

                if ((c.KeyChar == 'Y') || (c.KeyChar == 'y'))
                {
                    //Call complete on the scope
                    scope.Complete();
                    break;
                }
                else if ((c.KeyChar == 'N') || (c.KeyChar == 'n'))
                {
                    break;
                }
            }
        }
    }
    catch (System.Transactions.TransactionException ex)
    {
        Console.WriteLine(ex);
    }
    catch
    {
        Console.WriteLine("Cannot complete transaction");
        throw;
    }
}

private static void WorkerThread(object transaction)
{
    //Create a DependentTransaction from the object passed to the WorkerThread
    DependentTransaction dTx = (DependentTransaction)transaction;

    //Sleep for 1 second to force the worker thread to delay
    Thread.Sleep(1000);

    //Pass the DependentTransaction to the scope, so that work done in the scope becomes part of the transaction passed to the worker thread
    using (TransactionScope ts = new TransactionScope(dTx))
    {
        //Perform transactional work here.

        //Call complete on the transaction scope
        ts.Complete();
    }

    //Call complete on the dependent transaction
    dTx.Complete();
}
Public Shared Sub Main()
    Try
        Using scope As TransactionScope = New TransactionScope()

            'Perform transactional work here.

            'Queue work item
            ThreadPool.QueueUserWorkItem(AddressOf WorkerThread, Transaction.Current.DependentClone(DependentCloneOption.BlockCommitUntilComplete))

            'Display transaction information
            Console.WriteLine("Transaction information:")
            Console.WriteLine("ID:             {0}", Transaction.Current.TransactionInformation.LocalIdentifier)
            Console.WriteLine("status:         {0}", Transaction.Current.TransactionInformation.Status)
            Console.WriteLine("isolationlevel: {0}", Transaction.Current.IsolationLevel)

            'Call Complete on the TransactionScope based on console input
            Dim c As ConsoleKeyInfo
            While (True)

                Console.Write("Complete the transaction scope? [Y|N] ")
                c = Console.ReadKey()
                Console.WriteLine()
                If (c.KeyChar = "Y") Or (c.KeyChar = "y") Then
                    scope.Complete()
                    Exit While
                ElseIf ((c.KeyChar = "N") Or (c.KeyChar = "n")) Then
                    Exit While
                End If
            End While
        End Using

    Catch ex As TransactionException
        Console.WriteLine(ex)
    Catch
        Console.WriteLine("Cannot complete transaction")
        Throw
    End Try
End Sub

Public Shared Sub WorkerThread(ByVal myTransaction As Object)

    'Create a DependentTransaction from the object passed to the WorkerThread
    Dim dTx As DependentTransaction
    dTx = CType(myTransaction, DependentTransaction)

    'Sleep for 1 second to force the worker thread to delay
    Thread.Sleep(1000)

    'Pass the DependentTransaction to the scope, so that work done in the scope becomes part of the transaction passed to the worker thread
    Using ts As TransactionScope = New TransactionScope(dTx)
        'Perform transactional work here.

        'Call complete on the transaction scope
        ts.Complete()
    End Using

    'Call complete on the dependent transaction
    dTx.Complete()
End Sub

Commenti

DependentTransactionÈ un clone di un Transaction oggetto creato utilizzando il DependentClone metodo.The DependentTransaction is a clone of a Transaction object created using the DependentClone method. Il suo unico scopo è consentire all'applicazione di passare a Rest e garantire che non sia possibile eseguire il commit della transazione mentre il lavoro è ancora in corso sulla transazione, ad esempio in un thread di lavoro.Its sole purpose is to allow the application to come to rest and guarantee that the transaction cannot commit while work is still being performed on the transaction (for example, on a worker thread).

Quando le operazioni eseguite all'interno della transazione clonata sono infine complete e pronte per essere sottoposte a commit, è possibile informare il creatore della transazione utilizzando il Complete metodo.When the work done within the cloned transaction is finally complete and ready to be committed, it can inform the creator of the transaction using the Complete method. In questo modo è possibile mantenere la coerenza e la correttezza dei dati.Thus you can preserve the consistency and correctness of data.

L' DependentCloneOption enumerazione viene utilizzata per determinare il comportamento del commit.The DependentCloneOption enumeration is used to determine the behavior on commit. Questo controllo del comportamento consente a un'applicazione di passare a Rest, oltre a fornire il supporto per la concorrenza.This behavior control allows an application to come to rest, as well as provides concurrency support. Per ulteriori informazioni sull'utilizzo di questa enumerazione, vedere gestione della concorrenza con DependentTransaction.For more information on how this enumeration is used, see Managing Concurrency with DependentTransaction.

Proprietà

IsolationLevel

Ottiene il livello di isolamento della transazione.Gets the isolation level of the transaction.

(Ereditato da Transaction)
PromoterType

Identifica in modo univoco il formato dell'oggetto byte[] restituito dal metodo Promote quando la transazione viene promossa.Uniquely identifies the format of the byte[] returned by the Promote method when the transaction is promoted.

(Ereditato da Transaction)
TransactionInformation

Recupera informazioni aggiuntive su una transazione.Retrieves additional information about a transaction.

(Ereditato da Transaction)

Metodi

BeginCommitInternal(AsyncCallback) (Ereditato da Transaction)
Clone()

Crea un duplicato della transazione.Creates a clone of the transaction.

(Ereditato da Transaction)
Complete()

Tenta di completare la transazione dipendente.Attempts to complete the dependent transaction.

DependentClone(DependentCloneOption)

Crea un duplicato dipendente della transazione.Creates a dependent clone of the transaction.

(Ereditato da Transaction)
Dispose()

Rilascia le risorse contenute nell'oggetto.Releases the resources that are held by the object.

(Ereditato da Transaction)
EndCommitInternal(IAsyncResult) (Ereditato da Transaction)
EnlistDurable(Guid, IEnlistmentNotification, EnlistmentOptions)

Integra una gestione risorse durature che supporta il commit a due fasi per la partecipazione a una transazione.Enlists a durable resource manager that supports two phase commit to participate in a transaction.

(Ereditato da Transaction)
EnlistDurable(Guid, ISinglePhaseNotification, EnlistmentOptions)

Integra una gestione risorse durature che supporta l'ottimizzazione del commit a una fase per la partecipazione a una transazione.Enlists a durable resource manager that supports single phase commit optimization to participate in a transaction.

(Ereditato da Transaction)
EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification)

Inserisce un gestore risorse con una transazione interna che usa un'integrazione PSPE (Promotable Single Phase Enlistment).Enlists a resource manager that has an internal transaction using a promotable single phase enlistment (PSPE).

(Ereditato da Transaction)
EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification, Guid)

Inserisce un gestore risorse con una transazione interna che usa un'integrazione PSPE (Promotable Single Phase Enlistment).Enlists a resource manager that has an internal transaction using a promotable single phase enlistment (PSPE).

(Ereditato da Transaction)
EnlistVolatile(IEnlistmentNotification, EnlistmentOptions)

Integra un gestore di risorse volatili che supporta il commit a due fasi per partecipare a una transazione.Enlists a volatile resource manager that supports two phase commit to participate in a transaction.

(Ereditato da Transaction)
EnlistVolatile(ISinglePhaseNotification, EnlistmentOptions)

Integra una gestione risorse volatili che supporta l'ottimizzazione del commit a una fase per la partecipazione a una transazione.Enlists a volatile resource manager that supports single phase commit optimization to participate in a transaction.

(Ereditato da Transaction)
Equals(Object)

Determina se questa transazione e l'oggetto specificato sono uguali.Determines whether this transaction and the specified object are equal.

(Ereditato da Transaction)
GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

(Ereditato da Transaction)
GetPromotedToken()

Ottiene l'oggetto byte[] restituito dal metodo Promote quando la transazione viene promossa.Gets the byte[] returned by the Promote method when the transaction is promoted.

(Ereditato da Transaction)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
PromoteAndEnlistDurable(Guid, IPromotableSinglePhaseNotification, ISinglePhaseNotification, EnlistmentOptions)

Promuove e inserisce una gestione risorse duratura che supporta il commit a due fasi per la partecipazione a una transazione.Promotes and enlists a durable resource manager that supports two phase commit to participate in a transaction.

(Ereditato da Transaction)
Rollback()

Esegue il rollback (interruzione) della transazione.Rolls back (aborts) the transaction.

(Ereditato da Transaction)
Rollback(Exception)

Esegue il rollback (interruzione) della transazione.Rolls back (aborts) the transaction.

(Ereditato da Transaction)
SetDistributedTransactionIdentifier(IPromotableSinglePhaseNotification, Guid)

Imposta l'identificatore di transazione distribuita generato dal promotore non MSDTC.Sets the distributed transaction identifier generated by the non-MSDTC promoter.

(Ereditato da Transaction)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Eventi

TransactionCompleted

Indica che la transazione è stata completata.Indicates that the transaction is completed.

(Ereditato da Transaction)

Implementazioni dell'interfaccia esplicita

ISerializable.GetObjectData(SerializationInfo, StreamingContext)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Ottiene un oggetto SerializationInfo con i dati richiesti per la serializzazione di questa transazione.Gets a SerializationInfo with the data required to serialize this transaction.

(Ereditato da Transaction)

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche