DependentTransaction Classe

Définition

Décrit un clone d'une transaction qui garantit que la transaction ne peut pas être validée tant que l'application n'a pas fini son travail sur la transaction.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. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class DependentTransaction sealed : System::Transactions::Transaction, System::Runtime::Serialization::ISerializable
[System.Serializable]
public sealed class DependentTransaction : System.Transactions.Transaction, System.Runtime.Serialization.ISerializable
type DependentTransaction = class
    inherit Transaction
    interface ISerializable
Public NotInheritable Class DependentTransaction
Inherits Transaction
Implements ISerializable
Héritage
DependentTransaction
Attributs
Implémente

Exemples

L’exemple suivant montre comment créer une transaction dépendante.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

Remarques

Le DependentTransaction est un clone d' Transaction un objet créé à DependentClone l’aide de la méthode.The DependentTransaction is a clone of a Transaction object created using the DependentClone method. Son seul but est de permettre à l’application de passer au repos et de garantir que la transaction ne peut pas être validée tant que le travail est toujours en cours d’exécution sur la transaction (par exemple, sur un thread de travail).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).

Lorsque le travail effectué dans la transaction clonée est terminé et prêt à être validé, il peut informer le créateur de la transaction à l’aide Complete de la méthode.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. Vous pouvez ainsi préserver la cohérence et l’exactitude des données.Thus you can preserve the consistency and correctness of data.

L' DependentCloneOption énumération est utilisée pour déterminer le comportement de la validation.The DependentCloneOption enumeration is used to determine the behavior on commit. Ce contrôle de comportement permet à une application de passer au repos, et fournit la prise en charge de l’accès concurrentiel.This behavior control allows an application to come to rest, as well as provides concurrency support. Pour plus d’informations sur l’utilisation de cette énumération, consultez gestion de l’accès concurrentiel avec DependentTransaction.For more information on how this enumeration is used, see Managing Concurrency with DependentTransaction.

Propriétés

IsolationLevel

Obtient le niveau d'isolement de la transaction.Gets the isolation level of the transaction.

(Hérité de Transaction)
PromoterType

Identifie de façon unique le format de l’élément byte[] retourné par la méthode Promote quand la transaction est promue.Uniquely identifies the format of the byte[] returned by the Promote method when the transaction is promoted.

(Hérité de Transaction)
TransactionInformation

Récupère des informations supplémentaires à propos d'une transaction.Retrieves additional information about a transaction.

(Hérité de Transaction)

Méthodes

BeginCommitInternal(AsyncCallback) (Hérité de Transaction)
Clone()

Crée un clone de la transaction.Creates a clone of the transaction.

(Hérité de Transaction)
Complete()

Tente de terminer la transaction dépendante.Attempts to complete the dependent transaction.

DependentClone(DependentCloneOption)

Crée un clone dépendant de la transaction.Creates a dependent clone of the transaction.

(Hérité de Transaction)
Dispose()

Libère les ressources utilisées par l’objet.Releases the resources that are held by the object.

(Hérité de Transaction)
EndCommitInternal(IAsyncResult) (Hérité de Transaction)
EnlistDurable(Guid, IEnlistmentNotification, EnlistmentOptions)

Inscrit un gestionnaire de ressources durable qui prend en charge la validation à deux phases pour participer à une transaction.Enlists a durable resource manager that supports two phase commit to participate in a transaction.

(Hérité de Transaction)
EnlistDurable(Guid, ISinglePhaseNotification, EnlistmentOptions)

Inscrit un gestionnaire de ressources durable qui prend en charge l'optimisation de la validation à phase unique pour participer à une transaction.Enlists a durable resource manager that supports single phase commit optimization to participate in a transaction.

(Hérité de Transaction)
EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification)

Inscrit un gestionnaire de ressources qui a une transaction interne à l'aide d'une inscription à phase unique pouvant être promue (PSPE).Enlists a resource manager that has an internal transaction using a promotable single phase enlistment (PSPE).

(Hérité de Transaction)
EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification, Guid)

Inscrit un gestionnaire de ressources qui a une transaction interne à l'aide d'une inscription à phase unique pouvant être promue (PSPE).Enlists a resource manager that has an internal transaction using a promotable single phase enlistment (PSPE).

(Hérité de Transaction)
EnlistVolatile(IEnlistmentNotification, EnlistmentOptions)

Inscrit un gestionnaire de ressources volatiles qui prend en charge la validation à deux phases pour participer à une transaction.Enlists a volatile resource manager that supports two phase commit to participate in a transaction.

(Hérité de Transaction)
EnlistVolatile(ISinglePhaseNotification, EnlistmentOptions)

Inscrit un gestionnaire de ressources volatil qui prend en charge l'optimisation de la validation à phase unique pour participer à une transaction.Enlists a volatile resource manager that supports single phase commit optimization to participate in a transaction.

(Hérité de Transaction)
Equals(Object)

Détermine si cette transaction et l'objet spécifié sont égaux.Determines whether this transaction and the specified object are equal.

(Hérité de Transaction)
GetHashCode()

Retourne le code de hachage de cette instance.Returns the hash code for this instance.

(Hérité de Transaction)
GetPromotedToken()

Obtient l’élément byte[] retourné par la méthode Promote quand la transaction est promue.Gets the byte[] returned by the Promote method when the transaction is promoted.

(Hérité de Transaction)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
PromoteAndEnlistDurable(Guid, IPromotableSinglePhaseNotification, ISinglePhaseNotification, EnlistmentOptions)

Favorise et inscrit un gestionnaire de ressources durable qui prend en charge la validation à deux phases pour participer à une transaction.Promotes and enlists a durable resource manager that supports two phase commit to participate in a transaction.

(Hérité de Transaction)
Rollback()

Restaure (abandonne) la transaction.Rolls back (aborts) the transaction.

(Hérité de Transaction)
Rollback(Exception)

Restaure (abandonne) la transaction.Rolls back (aborts) the transaction.

(Hérité de Transaction)
SetDistributedTransactionIdentifier(IPromotableSinglePhaseNotification, Guid)

Définit l'identificateur de transaction distribuée généré par le promoteur non-MSDTC.Sets the distributed transaction identifier generated by the non-MSDTC promoter.

(Hérité de Transaction)
ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Événements

TransactionCompleted

Indique que la transaction est terminée.Indicates that the transaction is completed.

(Hérité de Transaction)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi