如何通过泛型字段动态过滤IQueryable

Question

I'm trying to make a IDictionary<TKey, List<TSource>> class where I can decide the key by a func. I have managed to build the class with arrays like this (functions are simplified for examples sake):

private List<TSource> Filter(TKey key, Func<TSource, TKey> keySelector)
{
    IQueryable<TSource> source = GetSource(); // It's there
    IQueryable<TSource> filtered = source.Where(
        x => keySelector.Invoke(x).Equals(key)
        );
    return filtered.ToList();
}

But this works only with arrays and such, not with linq-to-sql. I understand this can be done with expressions, but thats mostly beyond me. I have googled and come up with the following functions:

private List<TSource> Filter(TKey key, Expression<Func<TSource, TKey>> keySelector)
{
    IQueryable<TSource> source = GetSource();
    Func<TSource, bool> compiledKeyFilter = GetFilter(keySelector);
    IEnumerable<TSource> filtered = source.Where(compiledKeyFilter);
    return filtered.ToList();
}
private Func<TSource, bool> GetFilter(Expression<Func<TSource, TKey>> expr)
{
    if (this.filter == null)
    {
        var invokedExpr = Expression.Invoke(expr, expr.Parameters.Cast<Expression>());
        var lamda = Expression.Lambda<Func<TSource, bool>>(
            Expression.Call(expr.Body, typeof(TKey).GetMethod("Equals", new[] { typeof(TKey) }), invokedExpr),
            expr.Parameters
            );
        this.filter = lamda.Compile();
    }

    return this.filter;
}

This currently returns all rows in the source. The expression should be reusable, not just for one-time execution. I found the following from SO ( Dynamically generated lookup key for IQueryable ), what I'm doing is quie similar. It works, but I'm unable to combine it with the compiled approach:

private Expression<Func<TSource, bool>> MakeFilterExpression(TKey key)
{
    var param = Expression.Parameter(typeof(TSource));
    return Expression.Lambda<Func<TSource, bool>>(
            Expression.Equal(
                Expression.Invoke(keySelector, param),
                Expression.Constant(key)
            ),
        param
        );
}

So I'm trying to come up with a class that I could use like this:

// Inside MyCache there would be something close to this:
class MyCache
{
    private Func<TSource, bool> filter;
    public MyCache(Expression<Func<TSource, TKey>> func)
    {
        this.filter = MakeFilter(func);
    }
    private Func<TSource, bool> MakeFilter(Expression<Func<TSource, TKey>> func)
    {
        // magic
    }
    public List<TSource> GetByKey(TKey key)
    {
        return GetSource().Where(this.filter(key)).ToList();
    }
}

// This is my class where I give my func to determine the key in ctor.
var cache = new MyCache<MySource>(x => x.myField);
var list1 = cache.GetByKey(3); // Now I have list to iterate.
var list2 = cache.GetByKey(4); // Here's another list.

Is it even possible to compile that into a reusable function? Help?!

Answer 1

If I understand your question correctly, then you are trying to come up with a version of the Filter method that works with LINQ-to-SQL queries given an Expression<Func<TSource, TKey>> key selector.

You can use the LINQKit library to help you with that. It allows you to invoke one expression from another one and then "expand" the result expression.

Here is how you would code your Filter method with the help of LINQKit:

private static List<TSource> Filter<TSource,TKey>(
    TKey key,
    Expression<Func<TSource, TKey>> keySelector)
{
    IQueryable<TSource> source = GetSource<TSource>(); // It's there

    Expression<Func<TSource, bool>> predicate = x => keySelector.Invoke(x).Equals(key);

    //LINQ-to-SQL cannot translate `Invoke` into SQL. However, after invoking this line
    //LINQKit would flatten the expression so that it contains something like
    //x => x.Age.Equals(5) (for a keySelector of value x => x.Age and key of value 5)
    predicate = predicate.Expand();

    IQueryable<TSource> filtered = source.Where(predicate);

    return filtered.ToList();
}