如何重新包装Linq表达式树

本文关键字：表达式 Linq 包装 何重新 | 更新日期: 2023-09-27 18:10:40

我有一个Expression<Func<Entity, string>>，可以是一个属性或嵌套属性访问器

y => y.SearchColumn

或

y => y.SubItem.SubColumn

我正在动态地建立一个表达式树，并希望得到这样一个InvokeExpression 

x => x.SearchColumn.Contains("foo");
x => x.Sub.SearchColumn.Contains("foo");

我很确定我可以打开表达式体，然后部分地应用x ParameterExpression，但我不知道让这发生的魔法咒语

所以我有像

这样的东西
Expression<Func<Entity, string>> createContains(Expression<Func<Entity, string>> accessor) {
    var stringContains = typeof(String).GetMethod("Contains", new [] { typeof(String) });
    var pe = Expression.Parameter(typeof(T), "__x4326");
    return Expression.Lambda<Func<Entity, bool>>(
        Expression.Call(
            curryExpression(accessor.Body, pe),
            stringContains,
            Expression.Constant("foo")
        )
        , pe
    );              
}
    static Expression curryExpression(Expression from, ParameterExpression parameter) {
        // this doesn't handle the sub-property scenario
        return Expression.Property(parameter, ((MemberExpression) from).Member.Name);
        //I thought this would work but it does not
        //return Expression.Lambda<Func<Entity,string>>(from, parameter).Body;
    }
编辑:

这是我要做的完整的事情还有错误

如何重新包装Linq表达式树

你需要做两件事-第一，你可以使用相同的accessor.Body，但它会引用不正确的参数，因为你创建了一个新的。第二步，您需要编写自定义ExpressionVisitor，它将替换原始y ParameterExpression的所有使用到一个新的创建，因此结果表达式将被编译得很好。

如果您不需要创建新的ParameterExpression，那么您可以使用相同的accessor.Body并将原来的ParameterExpression重新创建到新的树中。

所以这里是我的测试工作副本与一个新的ParameterExpression - https://dotnetfiddle.net/uuPVAl

和代码本身

public class Program
{
    public static void Main(string[] args)
    {
        Expression<Func<Entity, string>> parent = (y) => y.SearchColumn;
        Expression<Func<Entity, string>> sub = (y) => y.Sub.SearchColumn;
        var result = Wrap(parent);
        Console.WriteLine(result);
        result.Compile();
        result = Wrap(sub);
        Console.WriteLine(result);
        result.Compile();
        result = Wrap<Entity>((y) => y.Sub.Sub.Sub.SearchColumn);
        Console.WriteLine(result);
        result.Compile();
    }
    private static Expression<Func<T, bool>> Wrap<T>(Expression<Func<T, string>> accessor)
    {
        var stringContains = typeof (String).GetMethod("Contains", new[] {typeof (String)});
        var pe = Expression.Parameter(typeof (T), "__x4326");
        var newBody = new ParameterReplacer(pe).Visit(accessor.Body);
        var call = Expression.Call(
            newBody,
            stringContains,
            Expression.Constant("foo")
            );
        return Expression.Lambda<Func<T, bool>>(call, pe);
    }
}
public class ParameterReplacer : ExpressionVisitor
{
    private ParameterExpression _target;
    public ParameterReplacer(ParameterExpression target)
    {
        _target = target;
    }
    protected override Expression VisitParameter(ParameterExpression node)
    {
        // here we are replacing original to a new one
        return _target;
    }
}
public class Entity
{
    public string SearchColumn { get; set; }
    public Entity Sub { get; set; }
}

PS:这个例子只适用于原始查询中只有一个ParameterExpression，否则访问者应该区分它们

这是我的工作答案与您的完整的例子更新- https://dotnetfiddle.net/MXP7wE

您只需要修复几件事:

  • 你的方法的返回类型应该是Expression<Func<T, bool>>。
  • Expression.Call()的第一个参数应该是accessor.Body。
  • Expression.Lambda<Func<T, bool>>()方法调用的ParameterExpression参数应该简单地从accessor的参数中设置。

方法: 

Expression<Func<T, bool>> CreateContains<T>(Expression<Func<T, string>> accessor)
{
    var stringContains = typeof(String).GetMethod("Contains", new[] { typeof(String) });
    return Expression.Lambda<Func<T, bool>>(
        Expression.Call(
            accessor.Body,
            stringContains,
            Expression.Constant("foo")
        )
        , accessor.Parameters[0]
    );
}
相关文章：