Menggunakan Transaksi atau SaveChanges (false) dan AcceptAllChanges ()?

Saya telah menyelidiki transaksi dan tampaknya bahwa mereka mengurus diri sendiri di EF selama saya lulus falseuntuk SaveChanges()dan kemudian memanggil AcceptAllChanges()jika ada kesalahan:

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

Bagaimana jika ada yang tidak beres? tidakkah saya harus mengembalikan atau, begitu metode saya keluar dari ruang lingkup, apakah transaksi berakhir?

Apa yang terjadi pada kolom indenty yang ditugaskan setengah jalan melalui transaksi? Saya kira jika orang lain menambahkan catatan setelah saya sebelum saya menjadi buruk maka ini berarti akan ada nilai Identitas yang hilang.

Apakah ada alasan untuk menggunakan TransactionScopekelas standar dalam kode saya?

Dengan Kerangka Entitas sebagian besar waktu SaveChanges()sudah cukup. Ini menciptakan transaksi, atau mendaftar dalam setiap transaksi ambient, dan melakukan semua pekerjaan yang diperlukan dalam transaksi itu.

Kadang-kadang meskipun SaveChanges(false) + AcceptAllChanges()berpasangan berguna.

Tempat yang paling berguna untuk ini adalah dalam situasi di mana Anda ingin melakukan transaksi terdistribusi di dua Konteks yang berbeda.

Yaitu sesuatu seperti ini (buruk):

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

Jika context1.SaveChanges()berhasil tetapi context2.SaveChanges()gagal seluruh transaksi yang didistribusikan dibatalkan. Namun sayangnya, Entity Framework telah membuang perubahan context1, sehingga Anda tidak dapat memutar ulang atau mencatat kegagalan secara efektif.

Tetapi jika Anda mengubah kode Anda menjadi seperti ini:

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

}

Sementara panggilan untuk SaveChanges(false)mengirim perintah yang diperlukan ke database, konteksnya sendiri tidak berubah, jadi Anda bisa melakukannya lagi jika perlu, atau Anda bisa menginterogasi ObjectStateManagerjika Anda mau.

Ini berarti jika transaksi benar-benar melempar pengecualian yang dapat Anda kompensasi, dengan mencoba kembali atau mencatat status dari setiap konteks di ObjectStateManagersuatu tempat.

Lihat posting blog saya untuk lebih lanjut.

Jika Anda menggunakan EF6 (Entity Framework 6+), ini telah berubah untuk panggilan basis data ke SQL.
Lihat: http://msdn.microsoft.com/en-us/data/dn456843.aspx

gunakan context.Database.BeginTransaction.

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

Karena beberapa basis data dapat melempar pengecualian di dbContextTransaction.Commit () jadi ini lebih baik:

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