获取完整的类属性“树”名称作为字符串

Question

我想要做的可能有点奇怪。 但是我正在尝试（这是我能解释的最好的）使用反射来获取完整的类属性树名称作为字符串。

---

成功的例子到目前为止：

通过使用表达式我可以转换：

() => Model.Cargo.Id

进入字符串：

"Model.Cargo.Id"

---

我现在的问题是，当我在混合中使用数组时，我没有得到数组名称。我得到的只是最后一个属性名称。

不成功的例子：

Model.CargoTasks[j].IsSet

只返回字符串：

"IsSet"

理想情况下我想要以下字符串结果：

"Model.CargoTasks[0].IsSet"

我可能要求有点多才能将索引包含在结果中，但如果这可能的话，那就太棒了。

---

我用来处理这些例子的代码如下：

public static string ToMemberAccess<TResult>(this Expression<Func<TResult>> expression)
{
    // Get the body of the expression
    Expression body = expression.Body;
    if (body.NodeType != ExpressionType.MemberAccess && body.NodeType != ExpressionType.Convert)
    {
        throw new ArgumentException("Property expression must be of the form '() => SomeProperty'", "expression");
    }

    var memberExpression = expression.Body as MemberExpression ?? ((UnaryExpression)expression.Body).Operand as MemberExpression;
    var stuff = GetMemberNames(memberExpression);
    stuff.Reverse();

    return string.Join(".", stuff);
}

static List<string> GetMemberNames(MemberExpression expression,  List<string> actual = null)
{
    if (actual == null) actual = new List<string>();

    var member = expression.Member;
    var subExp = expression.Expression as MemberExpression;
    actual.Add(member.Name);

    if(subExp != null) actual = GetMemberNames(subExp, actual);

    return actual;
}

谢谢提前！任何帮助将不胜感激！

Answer 1

要在索引器中获取值，您必须编译并执行表达式 - 这非常昂贵，但可以使用 ExpressionStringBuilder 的修改版本来完成。请注意，我添加了一个参数compileConstants。当它设置为false 时，输出将类似于Model.CargoTasks[_.j].IsSet。

请注意，此示例访问者不完整（即它不支持所有类型的表达式）。您可以使用code in GitHub 对其进行补充。

public static string ToMemberAccess<TResult>(Expression<Func<TResult>> expression, bool compileConstants = false)
{
    var builder = new ExpressionStringBuilder(compileConstants);
    builder.Visit(expression);
    return builder.ToString();
}

internal class ExpressionStringBuilder : ExpressionVisitor
{
    private readonly bool _compileConstants;
    private readonly StringBuilder _out;

    public ExpressionStringBuilder(bool compileConstants)
    {
        _compileConstants = compileConstants;
        _out = new StringBuilder();
    }

    protected override Expression VisitConstant(ConstantExpression node)
    {
        if (node.Value != null)
        {
            string text = node.Value.ToString();
            if (node.Value is string)
            {
                Out("\"");
                Out(text);
                Out("\"");
            }
            else if (text == node.Value.GetType().ToString())
            {
                Out('_');
            }
            else
            {
                Out(text);
            }
        }
        else
        {
            Out("null");
        }
        return node;
    }

    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        int num = 0;
        Expression expression = node.Object;
        if (Attribute.GetCustomAttribute(node.Method, typeof(ExtensionAttribute)) != null)
        {
            num = 1;
            expression = node.Arguments[0];
        }
        var name = node.Method.Name;
        var isIndexer = name == "get_Item";
        if (expression != null)
        {
            Visit(expression);
            if (!isIndexer)
            {
                Out('.');
            }
        }
        if (isIndexer)
            Out('[');
        else
        {
            Out(name);
            Out('(');
        }
        int i = num;
        int count = node.Arguments.Count;
        while (i < count)
        {
            if (i > num)
            {
                Out(", ");
            }
            VisitArgument(node.Arguments[i]);
            i++;
        }
        Out(isIndexer ? ']' : ')');
        return node;
    }

    protected override Expression VisitIndex(IndexExpression node)
    {
        if (node.Object != null)
        {
            Visit(node.Object);
        }
        else
        {
            Out(node.Indexer.DeclaringType.Name);
        }
        if (node.Indexer != null)
        {
            Out(".");
            Out(node.Indexer.Name);
        }

        Out('[');
        for (var index = 0; index < node.Arguments.Count; index++)
        {
            if (index > 0)
            {
                Out(", ");
            }
            var expression = node.Arguments[index];
            VisitArgument(expression);
        }
        Out(']');
        return node;
    }

    protected override Expression VisitLambda<T>(Expression<T> node)
    {
        Visit(node.Body);
        return node;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        OutMember(node.Expression, node.Member);
        return node;
    }

    public override string ToString()
    {
        return _out.ToString();
    }

    private void VisitArgument(Expression expression)
    {
        if (_compileConstants)
        {
            // TODO: possibly check the expression is not dependent on parameters
            var value = Expression.Lambda(expression).Compile().DynamicInvoke();
            Out(value + string.Empty);

        }
        else
        {
            VisitArgument(expression);
        }
    }

    private void OutMember(Expression instance, MemberInfo member)
    {
        if (instance != null)
        {
            Visit(instance);
            if (_out.Length > 0)
                Out('.');
            Out(member.Name);
            return;
        }
        Out(member.DeclaringType.Name + "." + member.Name);
    }

    private void Out(char c)
    {
        _out.Append(c);
    }

    private void Out(string s)
    {
        _out.Append(s);
    }
}