【问题标题】:Getting the object out of a MemberExpression?从 MemberExpression 中获取对象?
【发布时间】:2010-12-09 10:52:07
【问题描述】:

所以,假设我在 C# 中有以下表达式:

Expression<Func<string>> expr = () => foo.Bar;

如何提取对 foo 的引用?

【问题讨论】:

    标签: c# lambda expression-trees


    【解决方案1】:

    我遇到了同样的问题,但有点复杂,Darin Dimitrov 的回答给了我一个良好的开端。我会在这里发布我的结果,尽管这是一个“老”问题。


    案例一:根对象是实例成员

        this.textBox.Text    // where 'this' has type 'Form'
    

    ... 等价于以下表达式树:

    .                                    +====================+
    .                                    |  MemberExpression  |
    .                                    +====================+
    #                                      |                |
    #                          .Expression |                | .Member
    #                                      v                v
    .                    +------------------+              +------------+
    .                    | MemberExpression |              | MemberInfo |
    .                    +------------------+              +------------+
    #                      |              |                 .Name = "Text"
    #          .Expression |              | .Member         .MemberType = Property
    #                      v              v
    .   +--------------------+          +------------+
    .   | ConstantExpression |          | MemberInfo |
    .   +--------------------+          +------------+
    #    .Value = this                   .Name = "textBox"
    #    .Type  = typeof(Form)           .MemberType = Field
    

    在这个表达式树中,您实际获得对象引用的唯一位置是来自ConstantExpression:它允许您获得对this 的引用。因此,在这棵树中获取任何对象引用的基本思想如下:

    1. 沿.Expression 轴下降到表达式树,直到到达ConstantExpression 节点。

    2. 获取该节点的.Value 属性。这是根对象引用(即上面示例中的this)。

    3. 使用反射和表达式树中的 MemberInfo 节点,获取对象引用并按自己的方式“向上”返回表达式树。

    这里有一些代码可以证明这一点:

    Expression expr = ...;   // <-- initially set to the expression tree's root
    
    var memberInfos = new Stack<MemberInfo>();
    
    // "descend" toward's the root object reference:
    while (expr is MemberExpression)
    {
        var memberExpr = expr as MemberExpression;
        memberInfos.Push(memberExpr.Member);
        expr = memberExpr.Expression
    }
    
    // fetch the root object reference:
    var constExpr = expr as ConstantExpression;
    var objReference = constExpr.Value;
    
    // "ascend" back whence we came from and resolve object references along the way:
    while (memberInfos.Count > 0)  // or some other break condition
    {
        var mi = memberInfos.Pop();
        if (mi.MemberType == MemberTypes.Property)
        {
            objReference = objReference.GetType()
                                       .GetProperty(mi.Name)
                                       .GetValue(objReference, null);
        }
        else if (mi.MemberType == MemberTypes.Field)
        {
            objReference = objReference.GetType()
                                       .GetField(mi.Name)
                                       .GetValue(objReference);
        }
    }
    

    案例2:根对象是静态类成员

        Form.textBox.Text    // where 'textBox' is a static member of type 'Form'
    

    ... 生成不同的表达式树。注意左下角的空引用:

    .                                    +====================+
    .                                    |  MemberExpression  |
    .                                    +====================+
    #                                      |                |
    #                          .Expression |                | .Member
    #                                      v                v
    .                    +------------------+              +------------+
    .                    | MemberExpression |              | MemberInfo |
    .                    +------------------+              +------------+
    #                      |              |                 .Name = "Text"
    #          .Expression |              | .Member         .MemberType = Property
    #                      v              v
    .                     null          +------------+
    .                                   | MemberInfo |
    .                                   +------------+
    #                                   .Name = "textBox"
    #                                   .MemberType = Field
    #                                   .DeclaringType = typeof(Form)
    

    在这里,您无法通过等待ConstantExpression 来停止“下降”阶段。相反,当您到达空引用时,您会停止下降。接下来,您检索根对象引用,如下所示:

    var mi = memberInfos.Pop();
    objReference = mi.DeclaringType
                     .GetField(member.Name, BindingFlags.Static)  // or .GetProperty!
                     .GetValue(null);
    

    从那里开始的“上升”阶段与以前相同。


    当然还有更多的情况(比如命名参数作为根对象),但我希望到现在,我已经了解了基本概念,所以我就在这里打断了。

    【讨论】:

    • 非常全面的解释与只是一个答案! +1
    【解决方案2】:
    Expression<Func<string>> expr = () => foo.Bar;
    var me = (MemberExpression)((MemberExpression)expr.Body).Expression;
    var ce = (ConstantExpression)me.Expression;
    var fieldInfo = ce.Value.GetType().GetField(me.Member.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
    var value = (Foo)fieldInfo.GetValue(ce.Value);
    

    【讨论】:

    • 很好,只是用它来让一些交互测试更严格。
    【解决方案3】:

    有一个更简单的解决方案:

    var pExpression = ((MemberExpression)expr.Body);
    var bindingObject = Expression.Lambda(((MemberExpression)pExpression.Expression)).Compile().DynamicInvoke();
    

    【讨论】:

    • 哥们,你是MVP!
    【解决方案4】:

    谢谢,staks - 你的例子对我帮助很大!所以我想为第一个案例做一些补充:

    要从方法中提取值,应该替换代码:

    // fetch the root object reference:
    var constExpr = expr as ConstantExpression;
    var objReference = constExpr.Value;
    

    带代码:

        var newExpression = expr as NewExpression;
        if (newExpression != null)
        {                
            return newExpression.Constructor.Invoke(newExpression.Arguments.Select(GetObjectValue).ToArray());
        }
    
        var methodCallExpr = expr as MethodCallExpression;
        if (methodCallExpr != null)
        {
            var value = methodCallExpr.Method.Invoke(methodCallExpr.Object == null
                                                                     ? null
                                                                     : GetObjectValue(methodCallExpr.Object),
    methodCallExpr.Arguments.Select(GetObjectValue).ToArray());
                        return value;
        }
    
        // fetch the root object reference:
        var constExpr = expr as ConstantExpression;
        if (constExpr == null)
        {
             return null;
        }
        var objReference = constExpr.Value;
        // ... the rest remains unchanged
    

    这样就可以从以下表达式中提取值:

    aInstane.MethodCall(anArgument1, anArgument2) or
    AType.MethodCall(anArgument1, anArgument2) or
    new AType().MethodCall(anArgument1, aInstane.MethodCall(anArgument2, anArgument3))
    

    【讨论】:

      【解决方案5】:

      这是我在单元测试中使用的:

       internal static INotifyPropertyChanged SubModel < T, TProperty > (T model, Expression < Func < T, TProperty >> pickProperty) where T: INotifyPropertyChanged {
         MemberExpression memberExpression = (MemberExpression) pickProperty.Body;
         ParameterExpression parameterExpression = pickProperty.Parameters[0];
         Expression mem = memberExpression.Expression;
         var delegateType = typeof(Func < , > ).MakeGenericType(typeof(T), mem.Type);
         LambdaExpression lambdaExpression = Expression.Lambda(delegateType, mem, parameterExpression);
         object subModel = lambdaExpression.Compile().DynamicInvoke(model);
         return subModel as INotifyPropertyChanged ? ? model;
        }
      

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2013-08-11
        • 1970-01-01
        • 2015-01-11
        • 2013-05-10
        相关资源
        最近更新 更多