Come verificare se DbContext ha una transazione?

Question

Sfondo: Ho un servizio WCF con SimpleInjector come IoC che crea un'istanza di DbContext per richiesta WCF.

Il backend stesso è CQRS. CommandHandlers hanno un sacco di decoratori (convalida, autorizzazione, la registrazione, alcune regole comuni per i diversi gruppi di gestore, ecc) e uno di loro è Transaction Decorator:

public class TransactionCommandHandlerDecorator<TCommand> : ICommandHandler<TCommand> 
    where TCommand : ICommand 
{ 
    private readonly ICommandHandler<TCommand> _handler; 
    private readonly IMyDbContext _context; 
    private readonly IPrincipal _principal; 

    public TransactionCommandHandlerDecorator(ICommandHandler<TCommand> handler, 
     IMyDbContext context, IPrincipal principal) 
    { 
     _handler = handler; 
     _context = context; 
     _principal = principal; 
    } 

    void ICommandHandler<TCommand>.Handle(TCommand command) 
    { 
     using (var transaction = _context.Database.BeginTransaction()) 
     { 
      try 
      { 
       var user = _context.User.Single(x => x.LoginName == _principal.Identity.Name); 
       _handler.Handle(command); 
       _context.SaveChangesWithinExplicitTransaction(user); 
       transaction.Commit(); 
      } 
      catch (Exception ex) 
      { 
       transaction.Rollback(); 
       throw; 
      } 
     } 
    } 
} 

problema si verifica quando eventuali tentativi di comando a catena eseguire un altro comando all'interno della stessa richiesta WCF. Ho trovato un'eccezione prevista in questa linea:

using (var transaction = _context.Database.BeginTransaction()) 

perché il mio esempio DbContext ha già una transazione.

Esiste un modo per verificare l'esistenza della transazione corrente?

Answer 1

Anziché utilizzare la transazione dal DbContext di Entity Framework, è possibile o forse necessario utilizzare la classe TransactionScope che crea un ambito di transazione ambientale e gestisce le transazioni di tutte le connessioni effettuate al database (SQL) sotto le copertine.

Si potrebbe anche inserire un valore SqlCommand diretto nella stessa transazione se si utilizza il connettore di connessione esatto (con distinzione tra maiuscole e minuscole) per SqlCommand. I messaggi scritti su MessageQueue sono anche incapsulati nella stessa transazione

È anche possibile gestire le connessioni a diversi database allo stesso tempo. Per questo utilizza il servizio Windows DTC. Fai attenzione che questo è un problema da configurare se necessario. Normalmente, con una singola connessione DB (o più connessioni allo stesso DB) non è necessario il DTC.

Il TransactionScopeCommandHandlerDecorator implementazione è banale:

public class TransactionScopeCommandHandlerDecorator<TCommand> 
     : ICommandHandler<TCommand> 
{ 
    private readonly ICommandHandler<TCommand> decoratee; 

    public TransactionScopeCommandHandlerDecorator(ICommandHandler<TCommand> decoratee) 
    { 
     this.decoratee = decoratee; 
    } 

    public void Handle(TCommand command) 
    { 
     using (var scope = new TransactionScope()) 
     { 
      this.decoratee.Handle(command); 

      scope.Complete(); 
     } 
    } 
} 

Ma: Come qujck già accennato nei commenti, vi manca il concetto di ICommandHandler come un'operazione atomica. Un comandante non dovrebbe mai fare riferimento a un altro comandante. Non solo è male per le transazioni, ma considera anche questo:

Immagina che l'applicazione cresca e che tu possa refactoring alcuni dei tuoi commandhandler su un thread in background, che verrà eseguito in alcuni servizi di Windows. In questo servizio Windows non è disponibile uno stile di vita PerWcfOperation. Avresti bisogno di uno stile di vita LifeTimeScope per voi comandanti ora. Dal momento che il tuo design lo consente, il che è davvero fantastico !, tipicamente avvolgi i tuoi comandanti in un LifetimeScopeCommandHandler decorator per avviare LifetimeScope. Nel tuo progetto attuale in cui un singolo comandante di comandi fa riferimento ad altri comandanti che si imbatteranno in un problema, poiché ogni comandante sarà creato nel suo ambito, ottiene così un altro DbContext iniettato rispetto agli altri comandanti!

Quindi è necessario riprogettare e rendere i vostri commandhandler holistic abstractions e creare un'astrazione di livello inferiore per eseguire le operazioni DbContext.

Answer 2

penso che stai cercando il CurrentTransaction proprietà del DbContext:

var transaction = db.Database.CurrentTransaction; 

allora si può fare una verifica del genere:

using(var transaction = db.Database.CurrentTransaction ?? db.Database.BeginTransaction()) 
{ 
    ... 
} 

Tuttavia io non sono sicuro di come si può sapere quando eseguire il commit della transazione se è utilizzata da metodi concorrenti.