DependentCloneOption Enumerazione

Definizione

Spazio dei nomi:

System.Transactions

Assembly:

System.Transactions.Local.dll

Assembly:

System.Transactions.dll

Assembly:

netstandard.dll

Determina il tipo di transazione dipendente da creare.

C#

public enum DependentCloneOption

Ereditarietà

Object

ValueType

Enum

DependentCloneOption

Campi

BlockCommitUntilComplete	0	La transazione dipendente blocca il processo di esecuzione del commit della transazione fino al timeout della transazione padre oppure fino alla chiamata del metodo Complete(). In questo caso, può essere effettuata un'operazione aggiuntiva sulla transazione ed è possibile creare nuovi elenchi.
RollbackIfNotComplete	1	La transazione dipendente interrompe automaticamente la transazione se sulla transazione padre viene chiamato Commit prima di Complete().

Esempio

Nell'esempio seguente viene illustrato come creare una transazione dipendente.

C#

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

Commenti

Una transazione dipendente può essere ottenuta usando il metodo, con il DependentClone DependentCloneOption parametro che controlla il tipo di transazione dipendente da creare. Per altre informazioni su come viene usata questa enumerazione, vedere Gestione della concorrenza con DependentTransaction.

Si applica a

Vedi anche

• Gestione della concorrenza con DependentTransaction