Wie überprüft man, ob DbContext eine Transaktion hat?

Question

Hintergrund: Ich habe WCF-Dienst mit SimpleInjector als IoC, die Instanz von DbContext pro WCF-Anforderung erstellt.

Backend selbst ist CQRS. CommandHandlers haben viele Dekorateure (Validierung, Autorisierung, Protokollierung, einige gemeinsame Regeln für verschiedene Behandlungsgruppen usw.) und einer von ihnen ist Transaktion 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; 
      } 
     } 
    } 
} 

Problem tritt auf, wenn alle Befehl versucht, Kette innerhalb der anderen Befehl ausführen gleiche WCF-Anfrage. Ich habe eine erwartete Ausnahme bei dieser Zeile:

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

weil meine DbContext Instanz bereits eine Transaktion besitzt.

Gibt es eine Möglichkeit, aktuelle Transaktionen zu überprüfen?

Answer 1

Statt die Transaktion von der DbContext von Entity Framework verwenden könnten Sie oder vielleicht sollte die TransactionScope Klasse verwenden, die einen Umgebungstransaktionsbereich erstellt und verwaltet Transaktionen aller Verbindungen zum (SQL) Datenbank unter der Decke gemacht.

Es würde sogar eine direkte SqlCommand in der gleichen Transaktion, wenn Sie die genaue (case-sensitive) Connectionstring für die SqlCommand verwenden würde. Nachrichten geschrieben an die MessageQueue sind auch in der gleichen Transaktion gekapselt

Es könnte sogar Verbindungen zu verschiedenen Datenbanken zur gleichen Zeit verwalten. Dazu verwendet es den Windows-Dienst DTC. Beachten Sie, dass dies bei der Konfiguration ein Problem darstellt. Normalerweise benötigen Sie bei einer einzelnen DB-Verbindung (oder mehreren Verbindungen zu derselben DB) keinen DTC.

Die TransactionScopeCommandHandlerDecorator Implementierung ist trivial:

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

Aber: Wie qujck bereits in den Kommentaren erwähnt, werden Sie das Konzept der ICommandHandler als atomare Operation fehlt. Ein Commandhandler sollte niemals auf einen anderen Commandhandler verweisen. Das ist nicht nur schlecht für Transaktionen, sondern auch:

Stellen Sie sich vor, die Anwendung wächst und Sie würden einige Ihrer Commandhandler zu einem Hintergrund-Thread umgestalten, der in einigen Windows-Diensten ausgeführt wird. In diesem Windows-Dienst ist kein PerWcfOperation Lebensstil verfügbar. Sie würden jetzt einen LifeTimeScope Lifestyle für Ihre Commandhandler benötigen. Da Ihr Design es erlaubt, was übrigens großartig ist !, würden Sie Ihre Commandhandler normalerweise in eine LifetimeScopeCommandHandler decorator umwandeln, um die LifetimeScope zu starten. In Ihrem aktuellen Design, in dem ein einzelner Commandhandler auf andere Commandhandler verweist, werden Sie auf ein Problem stoßen, da jeder Commandhandler in seinem eigenen Bereich erstellt wird und somit ein anderer DbContext injiziert wird als die anderen Commandhandler!

Sie müssen also einige Redesign und machen Sie Ihre Commandhandler holistic abstractions und erstellen Sie eine niedrigere Abstraktion für die Durchführung der DbContext-Operationen.

Answer 2

Ich glaube, du bist für die CurrentTransaction Eigenschaft des DbContext suchen:

var transaction = db.Database.CurrentTransaction; 

Dann können Sie einen Scheck wie folgt tun:

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

aber ich bin nicht sicher, wie können Sie wissen, wann die Transaktion festgeschrieben werden soll, wenn sie von gleichzeitigen Methoden verwendet wird.