Vous utilisez Transactions ou SaveChanges (false) et AcceptAllChanges ()?

J'ai enquêté sur des transactions et il semble qu'elles se prennent en charge dans EF aussi longtemps que je passe falseà SaveChanges()puis appelle AcceptAllChanges()s'il n'y a pas d'erreur:

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

Et si quelque chose tourne mal? ne dois-je pas revenir en arrière ou, dès que ma méthode sort du champ d'application, la transaction est-elle terminée?

Qu'advient-il des colonnes d'indentation qui ont été affectées à mi-chemin de la transaction? Je suppose que si quelqu'un d'autre a ajouté un enregistrement après le mien avant que le mien ne tourne mal, cela signifie qu'il y aura une valeur d'identité manquante.

Y a-t-il une raison d'utiliser la TransactionScopeclasse standard dans mon code?

Avec Entity Framework, la plupart du temps SaveChanges()est suffisant. Cela crée une transaction ou s'inscrit dans une transaction ambiante et effectue tout le travail nécessaire dans cette transaction.

Parfois, même si l' SaveChanges(false) + AcceptAllChanges()association est utile.

L'endroit le plus utile pour cela est dans les situations où vous souhaitez effectuer une transaction distribuée dans deux contextes différents.

C'est à dire quelque chose comme ça (mauvais):

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

Si context1.SaveChanges()réussit mais context2.SaveChanges()échoue, la transaction distribuée entière est abandonnée. Mais malheureusement, Entity Framework a déjà ignoré les modifications context1, vous ne pouvez donc pas rejouer ou enregistrer efficacement l'échec.

Mais si vous changez votre code pour qu'il ressemble à ceci:

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

}

Pendant que l'appel à SaveChanges(false)envoie les commandes nécessaires à la base de données, le contexte lui-même n'est pas modifié, vous pouvez donc le refaire si nécessaire, ou vous pouvez interroger le ObjectStateManagersi vous le souhaitez.

Cela signifie que si la transaction lève réellement une exception, vous pouvez compenser, en réessayant ou en enregistrant l'état de chaque contexte ObjectStateManagerquelque part.

Voir mon article de blog pour en savoir plus.

Si vous utilisez EF6 (Entity Framework 6+), cela a changé pour les appels de base de données à SQL.
Voir: http://msdn.microsoft.com/en-us/data/dn456843.aspx

utilisez context.Database.BeginTransaction.

Depuis 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
        } 
    } 
} 

Parce que certaines bases de données peuvent lever une exception à dbContextTransaction.Commit () alors mieux cela:

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