EF-6-Parameter-Sniffing

Ist es möglich, das abfangen feature von EF6 zu manipulieren, um seine internen SQL-Befehle vor der Ausführung in DB, zum Beispiel das hinzufügen option(recompile) am Ende des Befehls:

public class OptionRecompileHintDbCommandInterceptor : IDbCommandInterceptor
{
    public void NonQueryExecuting(DbCommand command, DbCommandInterceptionContext<Int32> interceptionContext)
    {
    }

    public void NonQueryExecuted(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
    {
    }

    public void ReaderExecuted(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
    {
    }

    public void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
    {
        addQueryHint(command);
    }

    public void ScalarExecuted(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
    {
    }

    public void ScalarExecuting(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
    {
        addQueryHint(command);
    }

    private static void addQueryHint(IDbCommand command)
    {
        if (command.CommandType != CommandType.Text || !(command is SqlCommand))
            return;

        if (command.CommandText.StartsWith("select", StringComparison.OrdinalIgnoreCase) && !command.CommandText.Contains("option(recompile)"))
        {
            command.CommandText = command.CommandText + " option(recompile)";
        }
    }
}

Um es zu verwenden, fügen Sie die folgende Zeile am Anfang der Anwendung:

DbInterception.Add(new OptionRecompileHintDbCommandInterceptor());

Gleiche für mich wie für @Greg, ermöglicht dieses system breit war keine option, also schrieb ich dieses kleine utility-Klasse, die können temporäre hinzufügen-option(recompile) zu ausgeführten Abfragen innerhalb einer OptionRecompileScope.

Beispiel für die Verwendung

using (new OptionRecompileScope(dbContext))
{
    return dbContext.YourEntities.Where(<YourExpression>).ToList();
}

Umsetzung

public class OptionRecompileScope : IDisposable
{
    private readonly OptionRecompileDbCommandInterceptor interceptor;

    public OptionRecompileScope(DbContext context)
    {
        interceptor = new OptionRecompileDbCommandInterceptor(context);
        DbInterception.Add(interceptor);
    }

    public void Dispose()
    {
        DbInterception.Remove(interceptor);
    }

    private class OptionRecompileDbCommandInterceptor : IDbCommandInterceptor
    {
        private readonly DbContext dbContext;

        internal OptionRecompileDbCommandInterceptor(DbContext dbContext)
        {
            this.dbContext = dbContext;
        }

        public void NonQueryExecuting(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
        }

        public void NonQueryExecuted(DbCommand command, DbCommandInterceptionContext<int> interceptionContext)
        {
        }

        public void ReaderExecuting(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
        {
            if (ShouldIntercept(command, interceptionContext))
            {
                AddOptionRecompile(command);
            }
        }

        public void ReaderExecuted(DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)
        {
        }

        public void ScalarExecuting(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
            if (ShouldIntercept(command, interceptionContext))
            {
                AddOptionRecompile(command);
            }
        }

        public void ScalarExecuted(DbCommand command, DbCommandInterceptionContext<object> interceptionContext)
        {
        }

        private static void AddOptionRecompile(IDbCommand command)
        {
            command.CommandText = command.CommandText + " option(recompile)";
        }

        private bool ShouldIntercept(IDbCommand command, DbCommandInterceptionContext interceptionContext)
        {
            return 
                command.CommandType == CommandType.Text &&
                command is SqlCommand &&
                interceptionContext.DbContexts.Any(interceptionDbContext => ReferenceEquals(interceptionDbContext, dbContext));
        }
    }
}

Hatte einen ähnlichen Fall in EF Core 2, aber es unterscheidet sich nur in der Interceptor-Implementierung.
Da dieser thread hat mir geholfen, die meisten, möchte ich meine Umsetzung mit Euch, auch wenn die OP gefragt, für EF 6.
Außerdem verbesserte ich @Oskar Sjöberg und @Greg Lösung ein bisschen, um herauszufinden, das Abfragen, die verlängert werden sollte, mit der option recompile.

EF-Core-2-der Interceptor ist ein wenig knifflig und ein bisschen anders.

Kann realisiert werden über Paket Microsoft.Extensions.DiagnosticAdapter und den folgenden code

var contextDblistener = this.contextDb.GetService<DiagnosticSource>();
(contextDblistener as DiagnosticListener).SubscribeWithAdapter(new SqlCommandListener());

Den Interceptor selbst dann muss Ihre Methoden sind gekennzeichnet mit dem entsprechenden DiagnosticName Annotation.

Den tweak ich gab die Interceptor wurde, dass es sucht nach bestimmten tags (sql-Kommentare) in die Befehl um Abfragen, die sollten erweitert werden mit die gewünschte option.

Markieren Sie eine Abfrage verwenden Sie den recompile-option, Sie einfach hinzufügen ein .TagWith(Constants.SQL_TAG_QUERYHINT_RECOMPILE) auf die Abfrage, ohne Sie zu belästigen, um mit der Einstellung einen bool auf true und wieder auf false.

Diese Weise müssen Sie sich nicht auch ein problem mit parallelen Abfragen abgefangen werden und alle verlängert, mit einer option recompile wegen einem einzigen bool HintWithRecompile.

Die Konstante tag-strings sind so konzipiert, dass Sie nur in einem sql Kommentar und nicht Teil der Abfrage selbst.
Ich konnte keine Lösung finden, zu analysieren, nur der tag-Teil (detail von EF), so dass der gesamte sql-Befehl wird analysiert und Sie nicht möchten, fügen Sie eine neu kompilieren, da einige text in der Abfrage entspricht Ihre Flagge.

Dem "Optimize for Unknown" Teil, die verbessert werden können mit dem Befehl parameter-Eigenschaft, aber ich werde verlassen, dass bis zu Ihnen.

public class SqlCommandListener
{
    [DiagnosticName("Microsoft.EntityFrameworkCore.Database.Command.CommandExecuting")]
    public void OnCommandExecuting(DbCommand command, DbCommandMethod executeMethod, Guid commandId, Guid connectionId, bool async, DateTimeOffset startTime)
    {
        AddQueryHintsBasedOnTags(command);
    }

    [DiagnosticName("Microsoft.EntityFrameworkCore.Database.Command.CommandExecuted")]
    public void OnCommandExecuted(object result, bool async)
    {
    }

    [DiagnosticName("Microsoft.EntityFrameworkCore.Database.Command.CommandError")]
    public void OnCommandError(Exception exception, bool async)
    {
    }

    private static void AddQueryHintsBasedOnTags(DbCommand command)
    {
        if (command.CommandType != CommandType.Text || !(command is SqlCommand))
        {
            return;
        }

        if (command.CommandText.Contains(Constants.SQL_TAG_QUERYHINT_RECOMPILE) && !command.CommandText.Contains("OPTION (RECOMPILE)", StringComparison.InvariantCultureIgnoreCase))
        {
            command.CommandText = command.CommandText + "\nOPTION (RECOMPILE)";
        }
        else if (command.CommandText.Contains(Constants.SQL_TAG_QUERYHINT_OPTIMIZE_UNKNOWN_USER) && !command.CommandText.Contains("OPTION (OPTIMIZE FOR (@__SomeUserParam_0 UNKNOWN))", StringComparison.InvariantCultureIgnoreCase))
        {
            command.CommandText = command.CommandText + "\nOPTION (OPTIMIZE FOR (@__SomeUserParam_0 UNKNOWN))";
        }
    }
}