c# - 如何创建调用 IEnumerable.Any(...) 的表达式树？

Question

我正在尝试创建一个表示以下内容的表达式树:

myObject.childObjectCollection.Any(i => i.Name == "name");

为清楚起见，我有以下内容:

//'myObject.childObjectCollection' is represented here by 'propertyExp'
//'i => i.Name == "name"' is represented here by 'predicateExp'
//but I am struggling with the Any() method reference - if I make the parent method
//non-generic Expression.Call() fails but, as per below, if i use <T> the 
//MethodInfo object is always null - I can't get a reference to it

private static MethodCallExpression GetAnyExpression<T>(MemberExpression propertyExp, Expression predicateExp)
{
    MethodInfo method = typeof(Enumerable).GetMethod("Any", new[]{ typeof(Func<IEnumerable<T>, Boolean>)});
    return Expression.Call(propertyExp, method, predicateExp);
}

我做错了什么？有人有什么建议吗？

Answer 1

您的处理方式存在一些问题。

1. 您正在混合抽象级别。 T参数为GetAnyExpression<T>可能与用于实例化 propertyExp.Type 的类型参数不同. T 类型参数在抽象堆栈中离编译时间更近了一步——除非你调用 GetAnyExpression<T>通过反射，它将在编译时确定——但是表达式中嵌入的类型作为 propertyExp 传递在运行时确定。您将谓词作为 Expression 传递也是一个抽象混合 - 这是下一点。

2. 您要传递给 GetAnyExpression 的谓词应该是委托(delegate)值，而不是 Expression任何类型的，因为你想调用Enumerable.Any<T> .如果您尝试调用 Any 的表达式树版本, 那么你应该传递一个 LambdaExpression相反，您会引用它，这是您可能有理由传递比 Expression 更具体的类型的罕见情况之一，这引出了我的下一个观点。

3. 一般来说，你应该绕过Expression值。在一般情况下使用表达式树时——这适用于所有类型的编译器，而不仅仅是 LINQ 及其 friend ——你应该以一种与你正在使用的节点树的直接组成无关的方式进行操作。您假设您正在调用 Any在 MemberExpression 上，但实际上您并不需要知道您正在处理一个 MemberExpression , 只是一个 Expression属于 IEnumerable<> 的一些实例化类型.对于不熟悉编译器 AST 基础知识的人来说，这是一个常见的错误。 Frans Bouma当他第一次开始使用表达式树时，他多次犯同样的错误——在特殊情况下思考。一般认为。从中长期来看，您会省去很多麻烦。

4. 这就是您的问题的核心(尽管如果您已经解决了第二个问题，也可能是第一个问题，您可能会感到困扰)- 您需要找到 Any 方法的适当通用重载，然后实例化它具有正确的类型。 Reflection 并不能为您提供轻松的解决方案；您需要遍历并找到合适的版本。

因此，将其分解:您需要找到一个通用方法 ( Any )。这是执行此操作的实用程序函数:

static MethodBase GetGenericMethod(Type type, string name, Type[] typeArgs, 
    Type[] argTypes, BindingFlags flags)
{
    int typeArity = typeArgs.Length;
    var methods = type.GetMethods()
        .Where(m => m.Name == name)
        .Where(m => m.GetGenericArguments().Length == typeArity)
        .Select(m => m.MakeGenericMethod(typeArgs));

    return Type.DefaultBinder.SelectMethod(flags, methods.ToArray(), argTypes, null);
}

但是，它需要类型参数和正确的参数类型。从你的 propertyExp 获取Expression并不完全是微不足道的，因为 Expression可能属于 List<T>类型，或其他类型，但我们需要找到 IEnumerable<T>实例化并获取其类型参数。我已将其封装到几个函数中:

static bool IsIEnumerable(Type type)
{
    return type.IsGenericType
        && type.GetGenericTypeDefinition() == typeof(IEnumerable<>);
}

static Type GetIEnumerableImpl(Type type)
{
    // Get IEnumerable implementation. Either type is IEnumerable<T> for some T, 
    // or it implements IEnumerable<T> for some T. We need to find the interface.
    if (IsIEnumerable(type))
        return type;
    Type[] t = type.FindInterfaces((m, o) => IsIEnumerable(m), null);
    Debug.Assert(t.Length == 1);
    return t[0];
}

因此，给定任何 Type , 我们现在可以拉 IEnumerable<T>从中实例化 - 并断言是否(完全)没有。

有了这些工作，解决真正的问题就不会太困难了。我已将您的方法重命名为 CallAny，并按照建议更改了参数类型:

static Expression CallAny(Expression collection, Delegate predicate)
{
    Type cType = GetIEnumerableImpl(collection.Type);
    collection = Expression.Convert(collection, cType);

    Type elemType = cType.GetGenericArguments()[0];
    Type predType = typeof(Func<,>).MakeGenericType(elemType, typeof(bool));

    // Enumerable.Any<T>(IEnumerable<T>, Func<T,bool>)
    MethodInfo anyMethod = (MethodInfo)
        GetGenericMethod(typeof(Enumerable), "Any", new[] { elemType }, 
            new[] { cType, predType }, BindingFlags.Static);

    return Expression.Call(
        anyMethod,
            collection,
            Expression.Constant(predicate));
}

这是一个 Main()使用上述所有代码并验证它是否适用于简单情况的例程:

static void Main()
{
    // sample
    List<string> strings = new List<string> { "foo", "bar", "baz" };

    // Trivial predicate: x => x.StartsWith("b")
    ParameterExpression p = Expression.Parameter(typeof(string), "item");
    Delegate predicate = Expression.Lambda(
        Expression.Call(
            p,
            typeof(string).GetMethod("StartsWith", new[] { typeof(string) }),
            Expression.Constant("b")),
        p).Compile();

    Expression anyCall = CallAny(
        Expression.Constant(strings),
        predicate);

    // now test it.
    Func<bool> a = (Func<bool>) Expression.Lambda(anyCall).Compile();
    Console.WriteLine("Found? {0}", a());
    Console.ReadLine();
}