Entity Framework mit NOLOCK

Wie kann ich die NOLOCKFunktion in Entity Framework verwenden? Ist XML der einzige Weg, dies zu tun?

Nein, aber Sie können eine Transaktion starten und die Isolationsstufe so einstellen , dass sie nicht festgeschrieben wird . Dies macht im Wesentlichen dasselbe wie NOLOCK, aber anstatt es pro Tabelle zu tun, wird es für alles im Rahmen der Transaktion getan.

Wenn das so klingt, wie Sie es möchten, können Sie es folgendermaßen tun ...

//declare the transaction options
var transactionOptions = new System.Transactions.TransactionOptions();
//set it to read uncommited
transactionOptions.IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted;
//create the transaction scope, passing our options in
using (var transactionScope = new System.Transactions.TransactionScope(
    System.Transactions.TransactionScopeOption.Required, 
    transactionOptions)
)

//declare our context
using (var context = new MyEntityConnection())
{
    //any reads we do here will also read uncomitted data
    //...
    //...
    //don't forget to complete the transaction scope
    transactionScope.Complete();
}

Erweiterungsmethoden können dies erleichtern

public static List<T> ToListReadUncommitted<T>(this IQueryable<T> query)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required, 
        new TransactionOptions() { 
            IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }))
    {
        List<T> toReturn = query.ToList();
        scope.Complete();
        return toReturn;
    }
}

public static int CountReadUncommitted<T>(this IQueryable<T> query)
{
    using (var scope = new TransactionScope(
        TransactionScopeOption.Required, 
        new TransactionOptions() { 
            IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted }))
    {
        int toReturn = query.Count();
        scope.Complete();
        return toReturn;
    }
}

Wenn Sie etwas im Allgemeinen benötigen, ist es am besten, die Standardtransaktionsisolationsstufe für Ihre Verbindung festzulegen, nachdem Sie Ihren Objektkontext erstellt haben, indem Sie diesen einfachen Befehl ausführen:

this.context.ExecuteStoreCommand("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;");

http://msdn.microsoft.com/en-us/library/aa259216(v=sql.80).aspx

Mit dieser Technik konnten wir einen einfachen EF-Anbieter erstellen, der den Kontext für uns erstellt und diesen Befehl jedes Mal für den gesamten Kontext ausführt, sodass wir standardmäßig immer "nicht festgeschrieben" lesen.

Ich stimmte zwar absolut zu, dass die Verwendung der Isolationsstufe für nicht festgeschriebene Transaktionen die beste Wahl ist, aber einige Zeit haben Sie gezwungen, den NOLOCK-Hinweis auf Anfrage des Managers oder Kunden zu verwenden, und es wurden keine Gründe dafür akzeptiert.

Mit Entity Framework 6 können Sie Ihren eigenen DbCommandInterceptor wie folgt implementieren:

public class NoLockInterceptor : DbCommandInterceptor
{
    private static readonly Regex _tableAliasRegex = 
        new Regex(@"(?<tableAlias>AS \[Extent\d+\](?! WITH \(NOLOCK\)))", 
            RegexOptions.Multiline | RegexOptions.IgnoreCase);

    [ThreadStatic]
    public static bool SuppressNoLock;

    public override void ScalarExecuting(DbCommand command, 
        DbCommandInterceptionContext<object> interceptionContext)
    {
        if (!SuppressNoLock)
        {
            command.CommandText = 
                _tableAliasRegex.Replace(command.CommandText, "${tableAlias} WITH (NOLOCK)");
        }
    }

    public override void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
    {
        if (!SuppressNoLock)
        {
            command.CommandText = 
                _tableAliasRegex.Replace(command.CommandText, "${tableAlias} WITH (NOLOCK)");
        }
    }
}

Mit dieser Klasse können Sie sie beim Start der Anwendung anwenden:

DbInterception.Add(new NoLockInterceptor());

Deaktivieren Sie unter bestimmten Bedingungen das Hinzufügen von NOLOCKHinweisen zu Abfragen für den aktuellen Thread:

NoLockInterceptor.SuppressNoLock = true;

Verbesserung der akzeptierten Antwort von Doktor Jones und Verwendung von PostSharp ;

Zuerst " ReadUncommitedTransactionScopeAttribute "

[Serializable]
public class ReadUncommitedTransactionScopeAttribute : MethodInterceptionAspect
{
    public override void OnInvoke(MethodInterceptionArgs args)
    {
        //declare the transaction options
        var transactionOptions = new TransactionOptions();
        //set it to read uncommited
        transactionOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
        //create the transaction scope, passing our options in
        using (var transactionScope = new TransactionScope(TransactionScopeOption.Required, transactionOptions))
        {
            //declare our context
            using (var scope = new TransactionScope())
            {
                args.Proceed();
                scope.Complete();
            }
        }
    }
}

Dann, wann immer Sie es brauchen,

    [ReadUncommitedTransactionScope()]
    public static SomeEntities[] GetSomeEntities()
    {
        using (var context = new MyEntityConnection())
        {
            //any reads we do here will also read uncomitted data
            //...
            //...

        }
    }

Die Möglichkeit, "NOLOCK" mit einem Interceptor hinzuzufügen, ist ebenfalls hilfreich, funktioniert jedoch nicht, wenn eine Verbindung zu anderen Datenbanksystemen wie Oracle als solches hergestellt wird.

Um dies zu umgehen, erstelle ich eine Ansicht in der Datenbank und wende NOLOCK auf die Abfrage der Ansicht an. Ich behandle die Ansicht dann als Tabelle in EF.

Mit der Einführung von EF6 empfiehlt Microsoft die Verwendung der BeginTransaction () -Methode.

Sie können BeginTransaction anstelle von TransactionScope in EF6 + und EF Core verwenden

using (var ctx = new ContractDbContext())
using (var transaction = ctx.Database.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted))
{
    //any reads we do here will also read uncommitted data
}

Nein, nicht wirklich - Entity Framework ist im Grunde eine ziemlich strenge Schicht über Ihrer eigentlichen Datenbank. Ihre Abfragen werden in ESQL - Entity SQL - formuliert, das in erster Linie auf Ihr Entitätsmodell ausgerichtet ist. Da EF mehrere Datenbank-Backends unterstützt, können Sie "natives" SQL nicht direkt an Ihr Backend senden.

Der NOLOCK-Abfragehinweis ist eine SQL Server-spezifische Sache und funktioniert in keiner der anderen unterstützten Datenbanken (es sei denn, sie haben denselben Hinweis ebenfalls implementiert - was ich stark bezweifle).

Marc

Eine Möglichkeit besteht darin, eine gespeicherte Prozedur zu verwenden (ähnlich der von Ryan vorgeschlagenen Ansichtslösung) und dann die gespeicherte Prozedur von EF auszuführen. Auf diese Weise führt die gespeicherte Prozedur den Dirty Read durch, während EF nur die Ergebnisse weiterleitet.