¿Usando Transacciones o SaveChanges (false) y AcceptAllChanges ()?

He estado investigando las transacciones y parece que cuiden de sí mismos en EF, siempre y cuando paso falsea SaveChanges()y luego llamar AcceptAllChanges()si no hay errores:

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

¿Qué pasa si algo sale mal? ¿No tengo que retroceder o, tan pronto como mi método se sale del alcance, se finaliza la transacción?

¿Qué sucede con las columnas de sangría que se asignaron a la mitad de la transacción? Supongo que si alguien más agregó un registro después del mío antes de que el mío saliera mal, entonces esto significa que habrá un valor de identidad faltante.

¿Hay alguna razón para usar la TransactionScopeclase estándar en mi código?

Con Entity Framework, la mayoría de las veces SaveChanges()es suficiente. Esto crea una transacción, o se alista en cualquier transacción ambiental, y realiza todo el trabajo necesario en esa transacción.

A veces, aunque el SaveChanges(false) + AcceptAllChanges()emparejamiento es útil.

El lugar más útil para esto es en situaciones en las que desea realizar una transacción distribuida en dos contextos diferentes.

Es decir, algo como esto (malo):

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()tiene éxito pero context2.SaveChanges()falla, se anula toda la transacción distribuida. Pero desafortunadamente, Entity Framework ya ha descartado los cambios context1, por lo que no puede reproducir o registrar efectivamente la falla.

Pero si cambia su código para que se vea así:

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

}

Si bien la llamada a SaveChanges(false)envía los comandos necesarios a la base de datos, el contexto en sí no cambia, por lo que puede hacerlo nuevamente si es necesario, o puede interrogar ObjectStateManagersi lo desea.

Esto significa que si la transacción realmente arroja una excepción que puede compensar, ya sea reintentando o registrando el estado de cada contexto en ObjectStateManageralguna parte.

Vea mi publicación de blog para más.

Si está utilizando EF6 (Entity Framework 6+), esto ha cambiado para las llamadas de la base de datos a SQL.
Ver: http://msdn.microsoft.com/en-us/data/dn456843.aspx

use context.Database.BeginTransaction.

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

Debido a que alguna base de datos puede lanzar una excepción en dbContextTransaction.Commit (), mejor esto:

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