Wie verwendet man Transaktionen mit dem Entity Framework?

Question

Wenn Sie einen Code wie diesen haben:

Something something = new Something();
BlahEntities b = new BlahEntities()    
b.AddToSomethingSet(something);
b.SaveChanges();

Wie führt man diesen Zusatz innerhalb einer Transaktion aus?

Answer 1

Der ObjectContext verfügt über eine Verbindungseigenschaft, die Sie zur Verwaltung von Transaktionen verwenden können.

using (var context = new BlahEntities())
using (var tx = context.BeginTransaction())
{
    // do db stuff here...
    tx.Commit();
}

Im Falle einer Ausnahme wird die Transaktion rückgängig gemacht. Da der Aufruf von BeginTransaction() eine offene Verbindung erfordert, ist es sinnvoll, den Aufruf von BeginTransaction möglicherweise in eine Erweiterungsmethode zu verpacken.

public static DbTransaction BeginTransaction(this ObjectContext context)
{
    if (context.Connection.State != ConnectionState.Open)
    {
        context.Connection.Open();
    }
    return context.Connection.BeginTransaction();
}

Ein Szenario, in dem dieser Ansatz meiner Meinung nach gegenüber TransactionScope nützlich sein könnte, ist, wenn Sie auf zwei Datenquellen zugreifen müssen und nur für eine der Verbindungen Transaktionskontrolle benötigen. Ich denke, dass TransactionScope in diesem Fall zu einer verteilten Transaktion übergehen wird, die möglicherweise nicht erforderlich ist.

Answer 2

Sie können Ihren Code innerhalb eines Transaktionsbereichs platzieren

using(TransactionScope scope = new TransactionScope())
{
    // Your code
    scope.Complete(); //  To commit.
}

TransactionScope befindet sich im System.Transactions-Namensraum, der sich in der gleichnamigen Assembly befindet (die Sie möglicherweise manuell zu Ihrem Projekt hinzufügen müssen).

Answer 3

Ich weiß, dass für LINQ to SQL, der Datenkontext eine Transaktion für SubmitChanges() erstellt, wenn es keine vorhandene umgebende Transaktion gibt (TransactionScope ist eine "umgebende" Transaktion). Ich habe nicht gesehen, dass dies für LINQ to Entities dokumentiert ist, aber ich habe Verhalten gesehen, das darauf hindeutet, dass es auch für Entity Framework gilt.

Solange Sie also ein SubmitChanges() (L2SQL) oder SaveChanges() (Linq to Entities) für alle damit zusammenhängenden Änderungen verwenden, sollten Sie ohne TransactionScope auskommen. Sie brauchen einen TransactionScope, wenn

1. Speichern von mehreren Änderungen mit mehreren SubmitChanges/SaveChanges für eine Transaktion.
2. Aktualisierung mehrerer Datenquellen innerhalb einer Transaktion (z.B. Linq und ASP.NET membership SQL provider).
3. Aufrufen anderer Methoden, die ihre eigenen Aktualisierungen vornehmen können.

Ich habe Probleme mit verschachtelten TransactionScopes gehabt. Sie sollen funktionieren, und einfache Testfälle funktionieren, aber wenn ich in den Produktionscode gehe, scheint die "innere" Transaktion dasselbe Objekt zu sein wie die äußere Transaktion. Zu den Symptomen gehören Fehler, die entweder lauten "transaction committed, you can't use this transaction any more" oder "this transaction object has already been disposed". Die Fehler treten in der äußeren Transaktion auf, nachdem die innere Transaktion ihre Arbeit erledigt hat.

Answer 4

using System.Transactions;

using (TransactionScope scope = new TransactionScope())
{
    try
    {
        using(DataContext contextObject = new DataContext(ConnectionString))
        {
            contextObject.Connection.Open();
            // First SaveChange method.
            contextObject.SaveChanges();

            // Second SaveChange method.
            contextObject.SaveChanges();
            //--continue to nth save changes

            // If all execution successful
            scope.Complete();   
       }
    }
    catch(Exception ex)
    {
        // If any exception is caught, roll back the entire transaction and end the scope.
        scope.Dispose();
    }
    finally
    {
        // Close the opened connection
        if (contextObject.Connection.State == ConnectionState.Open)
        {
            contextObject.Connection.Close();
        }
    }
}

Ausführliche Erläuterungen finden Sie unter folgendem Link https://msdn.microsoft.com/en-us/data/dn456843.aspx

Answer 5

In allen Versionen von Entity Framework wird bei jeder Ausführung von SaveChanges() zum Einfügen, Aktualisieren oder Löschen in der Datenbank diese Operation in eine Transaktion verpackt. Diese Transaktion dauert nur lange genug, um die Operation auszuführen und wird dann beendet. Wenn Sie eine weitere solche Operation ausführen, wird eine neue Transaktion gestartet. Für die neueste Entity Framework Version: 6.0 +

Lesen Sie hier mehr: EntityFramework und Transaktion