使用 Contains 构建 Lambda 表达式

Question

我在将简单 linq 查询转换为 Lambda 表达式时遇到问题。

我的查询如下所示：

int[] array = List<int> array2 = sql.OfType<Table1>().Select(x=>x.ID).Take(10).ToList();
var result = sql.OfType<Table1>().Where(x => array.Contains(x.ID)).Take(10).ToList();

最终结果应该是：

static void DynamicSQLQuery<T>(IQueryable<T> sql, string fieldName)
{
    List<int> array = sql.OfType<T>().Select(SelectExpression<T>(fieldName)).Take(10).ToList();
    var result = sql.OfType<T>().Where(InExpression<T>(fieldName, array)).Take(10).ToList();
}

班级

public class Table1
{
    public int ID { get; set; }
    public string Name { get; set; }
}

我已经转换了第一个 lambda：

public static Expression<Func<T, int>> SelectExpression<T>(string fieldName)
{
    ParameterExpression param = Expression.Parameter(typeof(T), "x");
    MemberExpression selection = Expression.PropertyOrField(param, fieldName);
    var lambdaExp = Expression.Lambda<Func<T, int>>(selection, param);
    return lambdaExp;
}

但卡在第二个：

static Expression<Func<T, bool>> InExpression<T>(string propertyName,IEnumerable<int> array)
{
    System.Reflection.MethodInfo containsMethod = typeof(IEnumerable<int>).GetMethod("Contains");
    ParameterExpression param = Expression.Parameter(typeof(T), "x");
    MemberExpression member = Expression.PropertyOrField(param, propertyName);//x.{property}
    var constant = Expression.Constant(3);
    var body = Expression.GreaterThanOrEqual(member, constant); //x.{property} >= 3 but I need  array.Contains(x.{property})
    var finalExpression = Expression.Lambda<Func<T, bool>>(body, param);
    return finalExpression;
}

谁能帮我在 InExpression 方法中制作 lambda 表达式x=>array2.Contains(x.ID)？

另外，我将非常感谢有关创建这些类型的表达式的文章/教程的一些链接。

Answer 1

大概是这样的：

static Expression<Func<T, bool>> InExpression<T>(
    string propertyName, IEnumerable<int> array)
{
    var p = Expression.Parameter(typeof(T), "x");
    var contains = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
        .Single(x => x.Name == "Contains" && x.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(int));
    var property = Expression.PropertyOrField(p, propertyName);
    var body = Expression.Call(contains, Expression.Constant(array), property);
    return Expression.Lambda<Func<T, bool>>(body, p);
}

这里的技巧是从一些简单的可编译的东西开始；例如：

using System.Linq;
using System;
using System.Linq.Expressions;
using System.Collections.Generic;

public class C {
    static Expression<Func<Foo, bool>> InExpression<T>(
        string propertyName,IEnumerable<int> array)
    {
        return x => array.Contains(x.Id);
    }
}

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

现在，要么编译它并查看 ildasm/reflector，要么（而且更简单）：通过https://sharplab.io运行它，指定 C# 作为输出，如下所示

这显示了编译器生成的代码：

private static Expression<Func<Foo, bool>> InExpression<T>(string propertyName, IEnumerable<int> array)
{
    C.<>c__DisplayClass0_0<T> <>c__DisplayClass0_ = new C.<>c__DisplayClass0_0<T>();
    <>c__DisplayClass0_.array = array;
    ParameterExpression parameterExpression = Expression.Parameter(typeof(Foo), "x");
    Expression arg_77_0 = null;
    MethodInfo arg_77_1 = methodof(IEnumerable<!!0>.Contains(!!0));
    Expression[] expr_38 = new Expression[2];
    expr_38[0] = Expression.Field(Expression.Constant(<>c__DisplayClass0_, typeof(C.<>c__DisplayClass0_0<T>)), fieldof(C.<>c__DisplayClass0_0<T>.array));
    Expression[] expr_5F = expr_38;
    expr_5F[1] = Expression.Property(parameterExpression, methodof(Foo.get_Id()));
    Expression arg_86_0 = Expression.Call(arg_77_0, arg_77_1, expr_5F);
    ParameterExpression[] expr_82 = new ParameterExpression[1];
    expr_82[0] = parameterExpression;
    return Expression.Lambda<Func<Foo, bool>>(arg_86_0, expr_82);
}

请注意，这里有一些东西我们需要修复，但它使我们能够看到它正在做什么 - 例如，诸如memberof和 之类的东西fieldof实际上并不存在，因此我们需要通过反射查找它们。

上述内容的人性化版本：

private static Expression<Func<Foo, bool>> InExpression<T>(string propertyName, IEnumerable<int> array)
{
    ExpressionState state = new ExpressionState();
    state.array = array;
    ParameterExpression parameterExpression = Expression.Parameter(typeof(Foo), "x");
    MethodInfo contains = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
        .Single(x => x.Name == nameof(Enumerable.Contains) && x.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(int));
    Expression[] callArgs = new Expression[2];
    callArgs[0] = Expression.Field(Expression.Constant(state, typeof(ExpressionState)), nameof(ExpressionState.array));
    callArgs[1] = Expression.Property(parameterExpression, propertyName);
    Expression body = Expression.Call(null, contains, callArgs);
    ParameterExpression[] parameters = new ParameterExpression[1];
    parameters[0] = parameterExpression;
    return Expression.Lambda<Func<Foo, bool>>(body, parameters);
}

和：

class ExpressionState
{
    public IEnumerable<int> array;
}