Kraft Entity Framework SQL-Parametrisierung für bessere SQL-proc-cache Wiederverwendung

Update: Skip und Take Verlängerung Methoden, die lambda-Parameter, die unten beschrieben sind, sind Teil von Entity Framework ab version 6 und höher). Sie können nutzen Sie die durch den Import der System.Daten.Entity-namespace im code.

Im Allgemeinen LINQ to Entities übersetzt Konstanten als Konstanten und Variablen an die Abfrage übergeben in die Parameter.

Das problem ist, dass die Queryable-Versionen Überspringen und annehmen einfache integer-Parameter und nicht die lambda-Ausdrücke, also während LINQ to Entities können Sie sehen, die Werte, die Sie übergeben, es kann nicht sehen, die Tatsache, dass Sie verwendet eine variable zu übergeben (in anderen Worten, Methoden, wie das Überspringen und Nehmen Sie don T haben Zugang zu dem Verfahren der Schließung).

Dies betrifft nicht nur die Parametrierung in LINQ to Entities, sondern auch die erlernte Erwartung, dass, wenn Sie übergeben Sie eine variable, um eine LINQ-Abfrage der aktuelle Wert der variable verwendet wird, jedes mal, wenn Sie re-führen Sie die Abfrage. E. g., so etwas wie dies funktioniert, Wo aber nicht Überspringen, oder Nehmen Sie:

var letter = "";
var q = from db.Beattles.Where(p => p.Name.StartsWith(letter));

letter = "p";
var beattle1 = q.First(); //Returns Paul

letter = "j";
var beattle2 = q.First(); //Returns John

Beachten Sie, dass diese Besonderheit wirkt sich auch auf ElementAt aber dieser ist derzeit nicht unterstützt, die von LINQ to Entities.

Hier ist ein trick, den Sie verwenden können, um die Kraft der Parametrisierung von Überspringen und Nehmen, und zur gleichen Zeit, machen Sie sich mehr wie andere query-Operatoren:

public static class PagingExtensions
{
    private static readonly MethodInfo SkipMethodInfo = 
        typeof(Queryable).GetMethod("Skip");

    public static IQueryable<TSource> Skip<TSource>(
        this IQueryable<TSource> source, 
        Expression<Func<int>> countAccessor)
    {
        return Parameterize(SkipMethodInfo, source, countAccessor);
    }

    private static readonly MethodInfo TakeMethodInfo = 
        typeof(Queryable).GetMethod("Take");

    public static IQueryable<TSource> Take<TSource>(
        this IQueryable<TSource> source, 
        Expression<Func<int>> countAccessor)
    {
        return Parameterize(TakeMethodInfo, source, countAccessor);
    }

    private static IQueryable<TSource> Parameterize<TSource, TParameter>(
        MethodInfo methodInfo, 
        IQueryable<TSource> source, 
        Expression<Func<TParameter>>  parameterAccessor)
    {
        if (source == null) 
            throw new ArgumentNullException("source");
        if (parameterAccessor == null) 
            throw new ArgumentNullException("parameterAccessor");
        return source.Provider.CreateQuery<TSource>(
            Expression.Call(
                null, 
                methodInfo.MakeGenericMethod(new[] { typeof(TSource) }), 
                new[] { source.Expression, parameterAccessor.Body }));
    }
}

Der obigen Klasse definiert neue überlastungen Überspringen und Nehmen, die erwarten, dass ein lambda-Ausdruck, und kann daher-capture-Variablen. Mit den Methoden, wie dieses Ergebnis in der Variablen übersetzt Parameter, die von LINQ to Entities:

int x = 10;       
int y = 10;       

var query = context.Users.OrderBy(u => u.Id).Skip(() => x).Take(() => y);       

var result1 = query.ToList();

x = 20; 

var result2 = query.ToList();

Hoffe, das hilft.