DependentTransaction Classe

Définition

Espace de noms:

System.Transactions

Assembly:

System.Transactions.Local.dll

Source:

DependentTransaction.cs

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. Cette classe ne peut pas être héritée.

public ref class DependentTransaction sealed : System::Transactions::Transaction

public sealed class DependentTransaction : System.Transactions.Transaction

type DependentTransaction = class
    inherit Transaction

Public NotInheritable Class DependentTransaction
Inherits Transaction

Héritage

Object

Transaction

DependentTransaction

Exemples

L’exemple suivant montre comment créer une transaction dépendante.

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

est DependentTransaction un clone d’un Transaction objet créé à l’aide de la DependentClone méthode . Son seul objectif est de permettre à l’application de s’immobiler et de garantir que la transaction ne peut pas être validée alors que le travail est toujours en cours d’exécution sur la transaction (par exemple, sur un thread de travail).

Lorsque le travail effectué dans la transaction cloné est enfin terminé et prêt à être validé, il peut informer le créateur de la transaction à l’aide de la Complete méthode . Ainsi, vous pouvez préserver la cohérence et l’exactitude des données.

L’énumération DependentCloneOption est utilisée pour déterminer le comportement lors de la validation. Ce contrôle de comportement permet à une application de se mettre au repos et fournit une prise en charge de la concurrence. Pour plus d’informations sur l’utilisation de cette énumération, consultez Gestion de l’accès concurrentiel avec DependentTransaction.

Propriétés

IsolationLevel	Obtient le niveau d'isolement de la 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. (Hérité de Transaction)
TransactionInformation	Récupère des informations supplémentaires à propos d'une transaction. (Hérité de Transaction)

Méthodes

Clone()	Crée un clone de la transaction. (Hérité de Transaction)
Complete()	Tente de terminer la transaction dépendante.
DependentClone(DependentCloneOption)	Crée un clone dépendant de la transaction. (Hérité de Transaction)
Dispose()	Libère les ressources utilisées par l’objet. (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. (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. (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). (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). (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. (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. (Hérité de Transaction)
Equals(Object)	Détermine si cette transaction et l'objet spécifié sont égaux. (Hérité de Transaction)
GetHashCode()	Retourne le code de hachage de cette instance. (Hérité de Transaction)
GetPromotedToken()	Obtient le byte[] retourné par la Promote méthode lorsque la transaction est promue. (Hérité de Transaction)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (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. (Hérité de Transaction)
Rollback()	Restaure (abandonne) la transaction. (Hérité de Transaction)
Rollback(Exception)	Restaure (abandonne) la transaction. (Hérité de Transaction)
SetDistributedTransactionIdentifier(IPromotableSinglePhaseNotification, Guid)	Définit l'identificateur de transaction distribuée généré par le promoteur non-MSDTC. (Hérité de Transaction)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Événements

TransactionCompleted

Indique que la transaction est terminée. (Hérité de Transaction)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Obtient un SerializationInfo avec les données requises pour sérialiser cette transaction. (Hérité de Transaction)

Cohérence de thread

Ce type est thread-safe.

Voir aussi

• Gestion de l'accès concurrentiel avec DependentTransaction