如何重新包装 Linq 表达式树

Question

我有一个 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;
    }

编辑： Here is the full thing I'm trying to do along with the error

Answer 1

您需要做两件事 - 第一件您可以使用相同的 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

Answer 2

您只需要修复几件事：

Return 你方法的类型应该是 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]
    );
}

如何重新包装 Linq 表达式树

How to re-wrap a Linq Expression Tree

c#

linq

expression

metaprogramming

expression-trees