您不能在匿名 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);
}
另一种分页方法是返回 a 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);