Správa souběžnosti s DependentTransaction

Transaction Objekt je vytvořen pomocí DependentClone metody. Jejím jediným účelem je zajistit, že transakci nelze potvrdit při některých jiných částí kódu (například pracovní podproces) jsou stále provede práci na transakci. Při práci v rámci naklonované transakce je dokončena a připravena k potvrzené, jej můžete upozornit na transakci pomocí Tvůrce Complete metody. Proto můžete zachovat konzistence a správností data.

DependentTransaction Třídu lze použít také ke správě souběžnosti mezi asynchronní úlohy. V tomto případě mohou i nadále nadřazeného provést všechny kódu v době, kdy závislá kopie pracuje na své vlastní úlohy. Jinými slovy provádění nadřazeného objektu není blokován, dokud nebude dokončena závislé osoby.

Vytváření závislá kopie

Chcete-li vytvořit závislé transakci, zavolejte DependentClone a předáte DependentCloneOption výčet jako parametr. Tento parametr definuje chování transakce, pokud Commit je volána v nadřazené transakce před závislá kopie udává, zda je připravena k potvrzení transakce (voláním Complete metoda). Následující hodnoty jsou platné pro tento parametr:

• BlockCommitUntilComplete vytvoří závislá transakce, která blokuje proces potvrzení nadřazené transakce, dokud nadřazená transakce vyprší časový limit, nebo dokud Complete není volána na všech závislých závislosti označující jejich dokončení. To je užitečné, když klient nechce nadřazené transakce se zapsat, dokud závislé transakce byl dokončen. Je-li nadřazené dokončí svou práci starších než závislé transakce a volání Commit na transakci, je blokován procesu potvrzení ve stavu, kde další práce lze provést v transakci a nelze vytvořit nové zařazení, dokud všechny položky závislé na volání Complete. Jakmile je všechny dokončí jejich práce a volání Complete, začne procesu potvrzení pro transakci.

• RollbackIfNotComplete, na druhé straně vytvoří závislá transakce, která automaticky přeruší, pokud Commit je volána na nadřazené transakci před Complete voláním. V takovém případě všechny práci v závislé transakce je beze změny v rámci jedné transakce životnost a nemá nikdo příležitost dobře se zapsat jen jejich část.

Complete Metoda musí být volána pouze jednou, pokud vaše aplikace dokončí svou práci na závislé transakce. v opačném InvalidOperationException je vyvolána. Po zavolání toto volání nesmí provedením jakékoli další práce na transakci, nebo je vyvolána výjimka.

Následující příklad kódu ukazuje, jak vytvořit závislé transakci pro správu dvou souběžných úloh klonování závislé transakce a předáním k pracovní podproces.

public class WorkerThread  
{  
    public void DoWork(DependentTransaction dependentTransaction)  
    {  
        Thread thread = new Thread(ThreadMethod);  
        thread.Start(dependentTransaction);
    }  
  
    public void ThreadMethod(object transaction)
    {
        DependentTransaction dependentTransaction = transaction as DependentTransaction;  
        Debug.Assert(dependentTransaction != null);
        try  
        {  
            using(TransactionScope ts = new TransactionScope(dependentTransaction))  
            {  
                /* Perform transactional work here */
                ts.Complete();  
            }  
        }  
        finally  
        {  
            dependentTransaction.Complete();
             dependentTransaction.Dispose();
        }  
    }  
  
//Client code
using(TransactionScope scope = new TransactionScope())  
{  
    Transaction currentTransaction = Transaction.Current;  
    DependentTransaction dependentTransaction;
    dependentTransaction = currentTransaction.DependentClone(DependentCloneOption.BlockCommitUntilComplete);  
    WorkerThread workerThread = new WorkerThread();  
    workerThread.DoWork(dependentTransaction);  
    /* Do some transactional work here, then: */  
    scope.Complete();  
}  

Klientský kód vytvoří transakční obor, který nastaví také okolí transakce. Pracovní podproces by neměla předat okolí transakce. Namísto toho by měl klonovat aktuální (okolního) transakci voláním DependentClone metodu na aktuální transakci a předejte rolích dependent pracovní podproces.

ThreadMethod Metoda provádí u nového vlákna. Klient spustí nového vlákna, předávání závislé transakce, jako ThreadMethod parametru.

Vzhledem k tomu, že závislé transakce je vytvořen s BlockCommitUntilComplete, zaručuje, že transakci nelze zapsat do všech transakční práce vykonané na druhou po dokončení vlákna a Complete je volán na závislé transakce. To znamená, že pokud obor klienta končí (když se pokusí likvidovat objekt transakce na konci using příkazu) před voláním nového vlákna Complete závislé transakce, klientský kód blokuje, dokud Complete nebude volán na závislém. Poté můžete transakci dokončit potvrzení nebo přerušení.

Problémy s souběžnosti

Existuje několik dalších souběžnosti problémy, které potřebujete vědět, používáte-li DependentTransaction třídy:

• Pokud pracovní podproces vrátí zpět transakce, ale nadřazeného pokusí o potvrzení, TransactionAbortedException je vyvolána.

• Je třeba vytvořit nové závislá kopie pro každý pracovní podproces v transakci. Nepředávejte stejné závislá kopie na více vláknech, protože pouze jeden z nich může volat Complete v něm.

• Pokud pracovní podproces založí nový pracovní podproces, ujistěte se, k vytvoření závislá kopie z závislá kopie a předejte jí nové vlákno.

Viz také

• DependentTransaction