自动编译Linq查询

Question

我们发现编译Linq查询比每次编译要快得多,所以我们想开始使用编译查询.问题是它使代码更难阅读,因为查询的实际语法在某些其他文件中是关闭的,远离它的使用位置.

在我看来,有可能编写一个方法(或扩展方法),它使用反射来确定传入的查询,并自动缓存已编译的版本以供将来使用.

var foo = (from f in db.Foo where f.ix == bar select f).Cached();

Cached()必须反映传入的查询对象并确定所选的表和查询的参数类型.显然,反射有点慢,因此使用缓存对象的名称可能会更好(但是第一次编译查询时仍然需要使用反射).

var foo = (from f in db.Foo where f.ix == bar select f).Cached("Foo.ix");

有没有人有这方面的经验,或者知道它是否可能？

更新:对于那些没有看过它的人,可以使用以下代码将LINQ查询编译为SQL:

public static class MyCompiledQueries
{
    public static Func<DataContext, int, IQueryable<Foo>> getFoo =
        CompiledQuery.Compile(
            (DataContext db, int ixFoo) => (from f in db.Foo
                                            where f.ix == ixFoo
                                            select f)
        );
}

我想要做的是拥有这些Func<>对象的缓存,我可以在第一次自动编译查询后调用它们.

Answer 1

您不能在匿名lambda表达式上调用扩展方法,因此您将需要使用Cache类.为了正确缓存查询,您还需要将任何参数(包括DataContext)"提升"为lambda表达式的参数.这导致非常详细的用法,如:

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

为了清理它,如果我们将其设置为非静态的,我们可以基于每个上下文实例化一个QueryCache:

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

然后我们可以编写一个Cache方法,使我们能够编写以下内容:

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

您的查询中的任何参数也需要被取消:

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

这是我模拟的QueryCache实现:

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);
    }
}

这可以扩展为支持更多参数.最重要的是,通过将参数值传递给Cache方法本身,您可以获得lambda表达式的隐式类型.

编辑:请注意,您不能将新运算符应用于已编译的查询.具体而言,您不能执行以下操作:

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

因此,如果您计划分页查询,则需要在编译操作中执行此操作,而不是稍后执行.这不仅是为了避免异常,而且与Skip/Take的整个点保持一致(避免从数据库返回所有行).这种模式可行:

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);
}

分页的另一种方法是返回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);
}

这种模式使用如下:

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