EF: Wie rufe ich SaveChanges zweimal innerhalb einer Transaktion auf?

Question

Mit Entity Framework (Code zuerst in meinem Fall), habe ich eine Operation, die erfordert, dass ich SaveChanges aufrufen, um ein Objekt in der DB zu aktualisieren, und dann SaveChanges erneut, um ein anderes Objekt zu aktualisieren. (Ich brauche die ersten SaveChanges, um ein Problem zu lösen, bei dem EF nicht herausfinden kann, welches Objekt zuerst aktualisiert werden soll).

Ich habe versucht zu tun:

using (var transaction = new TransactionScope()) 
{ 
    // Do something 

    db.SaveChanges(); 

    // Do something else 

    db.SaveChanges(); 

    tramsaction.Complete(); 
} 

Wenn ich laufe, dass ich eine Ausnahme bei dem zweiten SaveChanges Anruf erhalten, sagen „die zugrunde liegenden Anbieter auf offene fehlgeschlagen“. Die innere Ausnahme besagt, dass MSDTC auf meinem Computer nicht aktiviert ist.

Jetzt habe ich Posts an anderer Stelle gesehen, die beschreiben, wie MSDTC zu aktivieren, aber es scheint, dass ich auch Netzwerkzugriff usw. aktivieren müssen. Das klingt wie komplette Overkill hier, da keine anderen Datenbanken beteiligt sind, lassen allein andere Server. Ich möchte nichts tun, was meine gesamte Anwendung weniger sicher (oder langsamer) macht.

Sicherlich muss es eine leichtere Möglichkeit geben, dies zu tun (idealerweise ohne MSDTC) ?!

Answer 1

Es wird wahrscheinlich durch zwei verschiedene Verbindungen in Ihrer Transaktion verursacht. Versuchen Sie Verbindung für Ihren Betrieb zu steuern manuell:

var objectContext = ((IObjectContextAdapter)db).ObjectContext; 

try { 
    object.Context.Connection.Open(); 
    using (var transaction = new TransactionScope()) { 
     // Do something 

     db.SaveChanges(); 

     // Do something else 

     db.SaveChanges(); 

     transaction.Complete(); 
    } 
} finally { 
    objectContext.Connection.Close(); 
} 

Answer 2

von Savechanges() aufrufen, wie Sie wird es bewirkt, dass die Daten in der Datenbank und dem EF beibehalten werden über die Änderungen zu vergessen es einfach gemacht.

Der Trick besteht darin, SaveChanges (false) zu verwenden, so dass die Änderungen in der DB beibehalten werden, aber EF nicht die Änderungen vergessen, die es macht, so dass Protokollierung/Wiederholung möglich.

 var scope = new TransactionScope(
      TransactionScopeOption.RequiresNew, 
      new TransactionOptions() { IsolationLevel = IsolationLevel.Serializable } 
     ); 

     using (scope) 
     { 
      Entities context1 = new Entities(); 
      // Do Stuff 
      context1.SaveChanges(false); 

      Entities context2 = new Entities(); 
      // Do Stuff 
      context2.SaveChanges(false); 

      scope.Complete(); 
      context1.AcceptAllChanges(); 
      context2.AcceptAllChanges(); 
     } 

P.S. Sobald innerhalb von transactionscope mehr als eine Verbindung geöffnet ist, eskaliert es zu DTC.

Answer 3

Ich weiß, es ist eine Art späte Antwort, aber ich fand es nützlich zu teilen.

Jetzt in EF6 es einfacher ist, dies acheeve von dbContext.Database.BeginTransaction()

wie folgt aus:

using (var context = new BloggingContext()) 
{ 
    using (var dbContextTransaction = context.Database.BeginTransaction()) 
    { 
     try 
     { 
      // do your changes 
      context.SaveChanges(); 

      // do another changes 
      context.SaveChanges(); 

      dbContextTransaction.Commit(); 
     } 
     catch (Exception) 
     { 
      dbContextTransaction.Rollback(); 
     } 
    } 
} 

für weitere Informationen Blick auf this

wieder ist es in EF6 Onwards

Answer 4

Für das Finale Antwort oben ausgewählt, gibt es einen Tippfehler. Korrigierte Zeile unter:

objectContext.Connection.Open(); 

Außerdem müssen Referenzen für System.Data.Entity.Infrastructure hinzufügen und System.Transactions