Verwenden von Transaktionen oder SaveChanges (false) und AcceptAllChanges ()?

Ich habe untersucht worden Transaktionen und es scheint , dass sie sich selbst in EF kümmern, solange ich pass falseauf SaveChanges()und rufen Sie dann , AcceptAllChanges()wenn es keine Fehler sind:

SaveChanges(false);
// ...
AcceptAllChanges();

Was ist, wenn etwas schief geht? Muss ich kein Rollback durchführen oder ist die Transaktion beendet, sobald meine Methode den Gültigkeitsbereich verlässt?

Was passiert mit Einrückungsspalten, die nach der Hälfte der Transaktion zugewiesen wurden? Ich nehme an, wenn jemand anderes einen Datensatz nach meinem hinzugefügt hat, bevor meiner schlecht wurde, bedeutet dies, dass ein Identitätswert fehlt.

Gibt es einen Grund, die Standardklasse TransactionScopein meinem Code zu verwenden?

Mit dem Entity Framework ist die meiste Zeit SaveChanges()ausreichend. Dadurch wird eine Transaktion erstellt oder eine Umgebungstransaktion eingetragen, und alle erforderlichen Arbeiten für diese Transaktion werden ausgeführt.

Manchmal ist die SaveChanges(false) + AcceptAllChanges()Paarung jedoch nützlich.

Der nützlichste Ort hierfür ist in Situationen, in denen Sie eine verteilte Transaktion über zwei verschiedene Kontexte ausführen möchten.

Dh so etwas (schlecht):

using (TransactionScope scope = new TransactionScope())
{
    //Do something with context1
    //Do something with context2

    //Save and discard changes
    context1.SaveChanges();

    //Save and discard changes
    context2.SaveChanges();

    //if we get here things are looking good.
    scope.Complete();
}

Wenn dies context1.SaveChanges()erfolgreich ist, aber context2.SaveChanges()fehlschlägt, wird die gesamte verteilte Transaktion abgebrochen. Leider hat das Entity Framework die Änderungen bereits verworfen context1, sodass Sie den Fehler nicht wiederholen oder effektiv protokollieren können.

Aber wenn Sie Ihren Code so ändern, dass er so aussieht:

using (TransactionScope scope = new TransactionScope())
{
    //Do something with context1
    //Do something with context2

    //Save Changes but don't discard yet
    context1.SaveChanges(false);

    //Save Changes but don't discard yet
    context2.SaveChanges(false);

    //if we get here things are looking good.
    scope.Complete();
    context1.AcceptAllChanges();
    context2.AcceptAllChanges();

}

Während der Aufruf zum SaveChanges(false)Senden der erforderlichen Befehle an die Datenbank wird der Kontext selbst nicht geändert, sodass Sie ihn bei Bedarf erneut ausführen oder bei Bedarf abfragen können ObjectStateManager.

Dies bedeutet, wenn die Transaktion tatsächlich eine Ausnahme auslöst, können Sie diese kompensieren, indem Sie den Status jedes Kontexts entweder erneut versuchen oder protokollieren ObjectStateManager.

Weitere Informationen finden Sie in meinem Blogbeitrag .

Wenn Sie EF6 (Entity Framework 6+) verwenden, hat sich dies für Datenbankaufrufe an SQL geändert.
Siehe: http://msdn.microsoft.com/en-us/data/dn456843.aspx

Verwenden Sie context.Database.BeginTransaction.

Von MSDN:

using (var context = new BloggingContext()) 
{ 
    using (var dbContextTransaction = context.Database.BeginTransaction()) 
    { 
        try 
        { 
            context.Database.ExecuteSqlCommand( 
                @"UPDATE Blogs SET Rating = 5" + 
                    " WHERE Name LIKE '%Entity Framework%'" 
                ); 

            var query = context.Posts.Where(p => p.Blog.Rating >= 5); 
            foreach (var post in query) 
            { 
                post.Title += "[Cool Blog]"; 
            } 

            context.SaveChanges(); 

            dbContextTransaction.Commit(); 
        } 
        catch (Exception) 
        { 
            dbContextTransaction.Rollback(); //Required according to MSDN article 
            throw; //Not in MSDN article, but recommended so the exception still bubbles up
        } 
    } 
} 

Da einige Datenbanken bei dbContextTransaction.Commit () eine Ausnahme auslösen können, ist dies besser:

using (var context = new BloggingContext()) 
{ 
  using (var dbContextTransaction = context.Database.BeginTransaction()) 
  { 
    try 
    { 
      context.Database.ExecuteSqlCommand( 
          @"UPDATE Blogs SET Rating = 5" + 
              " WHERE Name LIKE '%Entity Framework%'" 
          ); 

      var query = context.Posts.Where(p => p.Blog.Rating >= 5); 
      foreach (var post in query) 
      { 
          post.Title += "[Cool Blog]"; 
      } 

      context.SaveChanges(false); 

      dbContextTransaction.Commit(); 

      context.AcceptAllChanges();
    } 
    catch (Exception) 
    { 
      dbContextTransaction.Rollback(); 
    } 
  } 
}