Utilizzando Transactions o SaveChanges (false) e AcceptAllChanges ()?

Sono stato verifica delle operazioni e sembra che si prendono cura di se stessi in EF finché mi passa falseper SaveChanges()e quindi chiamare AcceptAllChanges()se non ci sono errori:

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

E se qualcosa va male? non devo eseguire il rollback o, non appena il mio metodo esce dal campo di applicazione, la transazione è terminata?

Cosa succede a tutte le colonne indipendenti che sono state assegnate a metà della transazione? Presumo che se qualcun altro ha aggiunto un record dopo il mio prima che il mio andasse male, questo significa che ci sarà un valore di identità mancante.

C'è qualche motivo per usare la TransactionScopeclasse standard nel mio codice?

Con Entity Framework la maggior parte del tempo SaveChanges()è sufficiente. Questo crea una transazione o si arruola in qualsiasi transazione ambientale e fa tutto il lavoro necessario in quella transazione.

A volte però l' SaveChanges(false) + AcceptAllChanges()abbinamento è utile.

Il posto più utile per questo è nelle situazioni in cui si desidera eseguire una transazione distribuita tra due diversi contesti.

Vale a dire qualcosa del genere (male):

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()riesce ma context2.SaveChanges()fallisce l'intera transazione distribuita viene interrotta. Ma sfortunatamente Entity Framework ha già scartato le modifiche context1, quindi non è possibile riprodurre o registrare efficacemente l'errore.

Ma se modifichi il codice in questo modo:

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

}

Mentre la chiamata a SaveChanges(false)invia i comandi necessari al database, il contesto stesso non viene modificato, quindi è possibile farlo di nuovo se necessario, oppure è possibile interrogare ObjectStateManagerse lo si desidera.

Ciò significa che se la transazione genera effettivamente un'eccezione che è possibile compensare, riprovando o registrando lo stato di ciascun contesto ObjectStateManagerda qualche parte.

Vedi il mio post sul blog per ulteriori informazioni.

Se si utilizza EF6 (Entity Framework 6+), questo è cambiato per le chiamate del database a SQL.
Vedi: http://msdn.microsoft.com/en-us/data/dn456843.aspx

usa context.Database.BeginTransaction.

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

Perché alcuni database possono generare un'eccezione su dbContextTransaction.Commit (), quindi meglio:

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