Usando transações ou SaveChanges (false) e AcceptAllChanges ()?

Tenho vindo a investigar transações e parece que eles cuidar de si na EF, enquanto eu passar falsepara SaveChanges()e, em seguida, chamar AcceptAllChanges()se não há erros:

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

E se algo der errado? não preciso reverter ou, assim que meu método estiver fora do escopo, a transação será encerrada?

O que acontece com qualquer coluna de identificação que tenha sido atribuída na metade da transação? Presumo que se alguém adicionou um registro após o meu antes que o meu ficasse ruim, isso significa que haverá um valor de identidade ausente.

Existe algum motivo para usar a TransactionScopeclasse padrão no meu código?

Com o Entity Framework, a maior parte do tempo SaveChanges()é suficiente. Isso cria uma transação ou inscreve-se em qualquer transação ambiental e faz todo o trabalho necessário nessa transação.

Às vezes, embora o SaveChanges(false) + AcceptAllChanges() emparelhamento seja útil.

O local mais útil para isso é em situações nas quais você deseja fazer uma transação distribuída em dois contextos diferentes.

Ou seja, algo assim (ruim):

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

Se context1.SaveChanges()for bem-sucedido, mas context2.SaveChanges()falhar, toda a transação distribuída é abortada. Infelizmente, porém, o Entity Framework já descartou as alterações context1, portanto você não pode reproduzir ou registrar efetivamente a falha.

Mas se você alterar seu código para ficar assim:

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

}

Enquanto a chamada SaveChanges(false)envia os comandos necessários para o banco de dados, o contexto em si não é alterado; portanto, você pode fazê-lo novamente, se necessário, ou pode interrogar oObjectStateManager que desejar.

Isso significa que, se a transação realmente lançar uma exceção, você poderá compensar, tentando novamente ou registrando o estado de cada contexto ObjectStateManager algum lugar.

Veja meu blog para mais.

Se você estiver usando EF6 (Entity Framework 6+), isso foi alterado para chamadas de banco de dados para SQL.
Consulte: http://msdn.microsoft.com/en-us/data/dn456843.aspx

use context.Database.BeginTransaction.

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

Como algum banco de dados pode lançar uma exceção em dbContextTransaction.Commit (), é melhor que isso:

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