创建 setter 表达式<Action<object， object>> from Expression<Func<IMyclass， int>>

Question

我有一个Expression<Func<IMyclass, int>>，我想将其转换为键入为 Expression<Action<object, object>> 的二传手。如何做到这一点？

问题是object参数。使用正确的类型(string(，这将很容易。

class Foo
{
    public Bar Bar { get; set; }
}
class Bar
{
    public string Baz { get; set; }    
}
static void Main(string[] args)
{
    var expr = GetExpression(t => t.Bar.Baz);
    var member = expr.Body as MemberExpression;
    var p = Expression.Parameter(typeof(object), "p");
    // This does not work...
    var assign = Expression.Assign(member, p);
    var lambda = Expression.Lambda<Action<object, object>>(assign, p);
    object o = new Foo();
    object v = "test";
    lambda.Compile().Invoke(o, v);
}
private static Expression<Func<Foo, string>> GetExpression(Expression<Func<Foo, string>> expr)
{
    return expr;
}

Answer 1

这是可能的，但不是微不足道的。首先，您需要重写原始表达式。现在它有这个形式：

(Foo t) => t.Bar.Baz;

你需要它像这样：

(object t) => ((Foo)t).Bar.Baz;

所以你需要表达式访问者：

private class ReplaceParameterExpressionVisitor : System.Linq.Expressions.ExpressionVisitor {
    private readonly ParameterExpression _toReplace;
    private readonly ParameterExpression _replaceWith;
    public ReplaceParameterExpressionVisitor(ParameterExpression toReplace, ParameterExpression replaceWith) {
        _toReplace = toReplace;
        _replaceWith = replaceWith;
    }            
    protected override Expression VisitParameter(ParameterExpression node) {
        if (node == _toReplace)
            // replace with new parameter and convert to the old parameter type
            return Expression.Convert(_replaceWith, _toReplace.Type);
        return base.VisitParameter(node);
    }
}

然后你的代码变成：

static void Main(string[] args)
{
    var expr = GetExpression(t => t.Bar.Baz);
    var member = expr.Body as MemberExpression;
    // define new parameter of type object
    var target = Expression.Parameter(typeof(object), "t");
    var value =  Expression.Parameter(typeof(object), "p");
    // replace old parameter of type Foo to new one
    member = (MemberExpression) new ReplaceParameterExpressionVisitor(expr.Parameters[0], target).Visit(member);
    // convert value to target type, because you cannot assign object to string
    var assign = Expression.Assign(member, Expression.Convert(value, member.Type));
    // now we have (target, value) => ((Foo)target).Bar.Baz = (string) value;
    var lambda = Expression.Lambda<Action<object, object>>(assign, target, value);
    var o = new Foo();
    // set bar or will throw null reference
    o.Bar = new Bar();
    object v = "test";
    lambda.Compile().Invoke(o, v);
}