包装表达式 <Func<T,bool> &gt;使用类型转换

Question

My repository returns entities derived from a common base class

class BaseClass
{
    public int Id { get; set; }
}

class MyClass : BaseClass
{
    public string Name { get; set; }
}

class MyOtherClass : BaseClass
{
    ...
}

in a function like this:

IQueryable<T> GetEntities<T>() where T : BaseClass

I added a method to register additional filters for specific entities as lambdas using Expression<Func<T,bool>> like this:

RegisterFilter<MyClass>(t => t.Name == "Test" );

that will be applied whenever GetEntities is called with MyClass in the type argument.

Question

How can I create an expression dynamically at runtime that wraps a type cast around the filter?

in my specific case GetEntities is called on an IQueryable<MyClass> using the BaseClass as type argument and event tough I know that the filter for MyClass needs to applied I did not find a way to do so:

IQueryable<BaseClass> src =
    (new List<MyClass>
    {
        new MyClass { Id = 1, Name = "asdf" },
        new MyClass { Id = 2, Name = "Test" }
    })
    .AsQueryable();

Expression<Func<MyClass, bool>> filter = o => o.Name == "Test";

// does not work (of course)
src.Where(filter);

Failed attempts

Obviously I could cast the collection back before calling Where but my attempts to do this at runtime did not work:

// HACK: don't look
var genericCast = typeof(Queryable).GetMethod("Cast").MakeGenericMethod(entityType);
var genericWhere = typeof(Queryable).GetMethods().Single(mi => mi.Name == "Where" && mi.GetParameters()[1].ParameterType.GenericTypeArguments[0].Name == "Func`2");
q = (IQueryable<T>)genericCast.Invoke(q, new object[] { genericWhere.Invoke(q, new object[] { filterExp }) });

System.InvalidOperationException: 'Late bound operations cannot be performed on types or methods for which ContainsGenericParameters is true.'

since this is also very ugly I tried to wrap my filter in cast like this:

LambdaExpression filterExp = (LambdaExpression)filter;
var call = filterExp.Compile();

Expression<Func<T, bool>> wrap = o => (bool)call.DynamicInvoke(Convert.ChangeType(o, entityType));

This works but prevents the filter to be generated into a store expression so it will be done in memory which is also undesirable.

I feel like the solution to this should be trivial but I can't seem to get it right so any help would be appreciated very much.

Answer 1

You can:

// Using SimpleExpressionReplacer from https://stackoverflow.com/a/29467969/613130
public static Expression<Func<BaseClass, bool>> Filter<TDerived>(Expression<Func<TDerived, bool>> test)
    where TDerived : BaseClass
{
    // x => 
    var par = Expression.Parameter(typeof(BaseClass), "x");

    // x is TDerived
    var istest = Expression.TypeIs(par, typeof(TDerived));

    // (TDerived)x
    var convert = Expression.Convert(par, typeof(TDerived));

    // If test is p => p.something == xxx, replace all the p with ((TDerived)x)
    var test2 = new SimpleExpressionReplacer(test.Parameters[0], convert).Visit(test.Body);

    // x is TDerived && test (modified to ((TDerived)x) instead of p)
    var and = Expression.AndAlso(istest, test2);

    // x => x is TDerived && test (modified to ((TDerived)x) instead of p)
    var test3 = Expression.Lambda<Func<BaseClass, bool>>(and, par);

    return test3;
}

Note that I'm using the SimpleExpressionReplacer I wrote in another answer.

Given a test like:

var exp = Filter<MyClass>(p => p.Name == "Test");

the resulting expression is:

x => x is MyClass && ((MyClass)x).Name == "Test"