In che modo TransactionScope ripristina le transazioni?

Sto scrivendo un test di integrazione in cui inserirò un numero di oggetti in un database e quindi verificherò se il mio metodo recupera quegli oggetti.

La mia connessione al database avviene tramite NHibernate ... e il mio metodo abituale per creare un test di questo tipo sarebbe di fare quanto segue:

NHibernateSession.BeginTransaction();

//use nhibernate to insert objects into database
//retrieve objects via my method
//verify actual objects returned are the same as those inserted

NHibernateSession.RollbackTransaction();

Tuttavia, di recente ho scoperto TransactionScope che apparentemente può essere utilizzato proprio per questo scopo ...

Alcuni esempi di codice che ho trovato sono i seguenti:

public static int AddDepartmentWithEmployees(Department dept)
{

    int res = 0;

    DepartmentAdapter deptAdapter = new DepartmentAdapter();
    EmployeeAdapter empAdapter = new EmployeeAdapter();
    using (TransactionScope txScope = new TransactionScope())
    {

        res += deptAdapter.Insert(dept.DepartmentName);
        //Custom method made to return Department ID 
        //after inserting the department "Identity Column"
        dept.DepartmentID = deptAdapter.GetInsertReturnValue();
        foreach(Employee emp in dept.Employees)
        {

            emp.EmployeeDeptID = dept.DepartmentID;
            res += empAdapter.Insert(emp.EmployeeName, emp.EmployeeDeptID);

        }
        txScope.Complete();

    }
    return res;

}

Credo che se non includo la riga, txScope.Complete()i dati inseriti verranno annullati. Ma purtroppo non capisco come ciò sia possibile ... come fa l' txScopeoggetto di tenere una traccia delle deptAdaptere empAdapteroggetti e le loro transazioni sul database.

Mi sento come se mi mancassero un po 'di informazioni qui ... sono davvero in grado di sostituire le mie chiamate BeginTransaction()and RollbackTransaction() circondando il mio codice usando TransactionScope?

In caso contrario, come TransactionScopefunziona il rollback delle transazioni?

In sostanza TransactionScope non tiene traccia dell'adattatore, quello che fa è tenere traccia delle connessioni al database. Quando apri una connessione DB, le connessioni controlleranno se è presente una transazione ambientale (Transaction Scope) e in tal caso si arruoleranno con essa. Attenzione, se ci sono più connessioni allo stesso server SQL, questo passerà a una transazione distribuita.

Cosa succede poiché stai usando un blocco using, stai assicurando che dispose verrà chiamato anche se si verifica un'eccezione. Quindi, se dispose viene chiamato prima di txScope.Complete (), TransactionScope dirà alle connessioni di eseguire il rollback delle loro transazioni (o del DTC).

La TransactionScopeclasse funziona con la Transactionclasse , che è specifica del thread.

Quando TransactionScopeviene creato, controlla se esiste un Transactionper il thread; se ne esiste uno lo usa, altrimenti ne crea uno nuovo e lo mette in pila.

Se ne utilizza uno esistente, incrementa semplicemente un contatore per i rilasci (dal momento che devi chiamarlo Dispose). Nell'ultima versione, se Transactionnon è stato commesso, ripristina tutto il lavoro.

Per quanto riguarda il motivo per cui le classi sembrano conoscere magicamente le transazioni, questo viene lasciato come dettaglio di implementazione per quelle classi che desiderano lavorare con questo modello.

Quando crei le tue istanze deptAdaptere emptAdapter, controllano per vedere se c'è una transazione corrente sul thread (la Currentproprietà statica sulla Transactionclasse). Se c'è, allora si registra con il Transaction, per prendere parte alla sequenza di commit / rollback (che Transactioncontrolla e potrebbe propagarsi a diversi coordinatori di transazione, come kernel, distribuito, ecc.).