Automatycznie Kompiluje Zapytania Linq

Nie możesz wywoływać metod rozszerzeń na anonimowych wyrażeniach lambda, więc będziesz chciał użyć klasy Cache. Aby poprawnie buforować zapytanie, musisz również "podnieść" wszelkie parametry (w tym DataContext) do parametrów dla wyrażenia lambda. Powoduje to bardzo wyraziste użycie, takie jak:

var results = QueryCache.Cache((MyModelDataContext db) => 
    from x in db.Foo where !x.IsDisabled select x);

Aby to wyczyścić, możemy utworzyć instancję QueryCache na podstawie kontekstu, jeśli uczynimy go niestatycznym:

public class FooRepository
{
    readonly QueryCache<MyModelDataContext> q = 
        new QueryCache<MyModelDataContext>(new MyModelDataContext());
}

Wtedy możemy napisać metodę Cache, która pozwoli nam napisać:

var results = q.Cache(db => from x in db.Foo where !x.IsDisabled select x);

Wszelkie argumenty w zapytaniu również będą musiały zostać usunięte:

var results = q.Cache((db, bar) => 
    from x in db.Foo where x.id != bar select x, localBarValue);

Oto implementacja QueryCache, którą wyśmiałem:

public class QueryCache<TContext> where TContext : DataContext
{
    private readonly TContext db;
    public QueryCache(TContext db)
    {
        this.db = db;
    }

    private static readonly Dictionary<string, Delegate> cache = new Dictionary<string, Delegate>();

    public IQueryable<T> Cache<T>(Expression<Func<TContext, IQueryable<T>>> q)
    {
        string key = q.ToString();
        Delegate result;
        lock (cache) if (!cache.TryGetValue(key, out result))
        {
            result = cache[key] = CompiledQuery.Compile(q);
        }
        return ((Func<TContext, IQueryable<T>>)result)(db);
    }

    public IQueryable<T> Cache<T, TArg1>(Expression<Func<TContext, TArg1, IQueryable<T>>> q, TArg1 param1)
    {
        string key = q.ToString();
        Delegate result;
        lock (cache) if (!cache.TryGetValue(key, out result))
        {
            result = cache[key] = CompiledQuery.Compile(q);
        }
        return ((Func<TContext, TArg1, IQueryable<T>>)result)(db, param1);
    }

    public IQueryable<T> Cache<T, TArg1, TArg2>(Expression<Func<TContext, TArg1, TArg2, IQueryable<T>>> q, TArg1 param1, TArg2 param2)
    {
        string key = q.ToString();
        Delegate result;
        lock (cache) if (!cache.TryGetValue(key, out result))
        {
            result = cache[key] = CompiledQuery.Compile(q);
        }
        return ((Func<TContext, TArg1, TArg2, IQueryable<T>>)result)(db, param1, param2);
    }
}

Można to rozszerzyć, aby wspierać więcej argumentów. Wielkim bitem jest to, że przekazując wartości parametrów do samej metody Cache, otrzymujesz niejawne wpisywanie wyrażenia lambda.

EDIT: zauważ, że nie możesz zastosować nowych operatorów do skompilowanych zapytań.. W szczególności nie możesz zrób coś takiego:

var allresults = q.Cache(db => from f in db.Foo select f);
var page = allresults.Skip(currentPage * pageSize).Take(pageSize);

Więc jeśli planujesz stronicowanie zapytania, musisz to zrobić w operacji kompilacji zamiast robić to później. Jest to konieczne nie tylko w celu uniknięcia wyjątku, ale również zgodnie z całym punktem Skip/Take (aby uniknąć zwracania wszystkich wierszy z bazy danych). Ten wzór zadziała:

public IQueryable<Foo> GetFooPaged(int currentPage, int pageSize)
{
    return q.Cache((db, cur, size) => (from f in db.Foo select f)
        .Skip(cur*size).Take(size), currentPage, pageSize);
}

Innym podejściem do przywoływania byłoby zwrócenie Func:

public Func<int, int, IQueryable<Foo>> GetPageableFoo()
{
    return (cur, size) => q.Cache((db, c, s) => (from f in db.foo select f)
        .Skip(c*s).Take(s), c, s);
}

Ten wzór jest używany w następujący sposób:

var results = GetPageableFoo()(currentPage, pageSize);