C#：从 lambda 表达式获取链中的属性名称

Question

我正在开发一个使用 lambda 表达式来指定属性的 API。我正在使用这段与此类似的著名代码（这是简化且不完整的，只是为了弄清楚我在说什么）：

public void Foo<T, P>(Expression<Func<T, P>> action)
{
    var expression = (MemberExpression)action.Body;
    string propertyName = expression.Member.Name;
    // ...
}

像这样调用：

Foo((String x) => x.Length);

现在我想通过链接属性来指定属性路径名称，如下所示：

Foo((MyClass x) => x.Name.Length);

Foo 应该能够将路径拆分为其属性名称（"Name" 和 "Length"）。有没有办法通过合理的努力来做到这一点？

---

有一个看起来类似的问题，但我认为他们正在尝试结合那里有 lambda 表达式。

另一个问题也正在处理嵌套属性名称，但我不太明白他们在说什么。

Answer 1

像这样的东西吗？

public void Foo<T, P>(Expression<Func<T, P>> expr)
{
    MemberExpression me;
    switch (expr.Body.NodeType)
    {
        case ExpressionType.Convert:
        case ExpressionType.ConvertChecked:
            var ue = expr.Body as UnaryExpression;
            me = ((ue != null) ? ue.Operand : null) as MemberExpression;
            break;
        default:
            me = expr.Body as MemberExpression;
            break;
    }

    while (me != null)
    {
        string propertyName = me.Member.Name;
        Type propertyType = me.Type;

        Console.WriteLine(propertyName + ": " + propertyType);

        me = me.Expression as MemberExpression;
    }
}

Answer 2

我玩了一下 ExpressionVisitor ：

public static class PropertyPath<TSource>
{
    public static IReadOnlyList<MemberInfo> Get<TResult>(Expression<Func<TSource, TResult>> expression)
    {
        var visitor = new PropertyVisitor();
        visitor.Visit(expression.Body);
        visitor.Path.Reverse();
        return visitor.Path;
    }

    private class PropertyVisitor : ExpressionVisitor
    {
        internal readonly List<MemberInfo> Path = new List<MemberInfo>();

        protected override Expression VisitMember(MemberExpression node)
        {
            if (!(node.Member is PropertyInfo))
            {
                throw new ArgumentException("The path can only contain properties", nameof(node));
            }

            this.Path.Add(node.Member);
            return base.VisitMember(node);
        }
    }
}

用法：

var path = string.Join(".", PropertyPath<string>.Get(x => x.Length).Select(p => p.Name));

Answer 3

老问题，我知道......但如果这只是您需要的名称，则更简单的方法是：

expr.ToString().Split('.').Skip(1) 

编辑：

public class A
{
    public B Property { get; set; }
}

public class B
{
    public C field;
}

[Fact]
public void FactMethodName()
{
    var exp = (Expression<Func<A, object>>) (x => x.Property.field);
    foreach (var part in exp.ToString().Split('.').Skip(1))
        Console.WriteLine(part);

    // Output:
    // Property
    // field
}

Answer 4

我在客户端和服务器之间有一个共享的 .NET 标准 DTO，表达式是创建可以在 Api 端重建和执行的查询字符串的好方法。

通过网络创建类型安全查询的完美方法。

我离题了，我还需要一个属性路径

x => x.Siblings.Age 

来生成一个像

"Siblings.Age"

我这样的字符串

    public static string GetMemberPath(MemberExpression me)
    {
        var parts = new List<string>();

        while (me != null)
        {
            parts.Add(me.Member.Name);
            me = me.Expression as MemberExpression;
        }

        parts.Reverse();
        return string.Join(".", parts);
    }

Answer 5

    public static string GetPath<T, TProperty>(this Expression<Func<T, TProperty>> exp)
    {
        return string.Join(".", GetItemsInPath(exp).Reverse());
    }

    private static IEnumerable<string> GetItemsInPath<T, TProperty>(Expression<Func<T, TProperty>> exp)
    {
        if (exp == null)
        {
            yield break;
        }
        var memberExp = FindMemberExpression(exp.Body);
        while (memberExp != null)
        {
            yield return memberExp.Member.Name;
            memberExp = FindMemberExpression(memberExp.Expression);
        }
    }

Answer 6

我重构了这些答案以使用递归，因此不需要反转顺序。我只需要属性树，因此省略了除 MemberExpressions 之外的所有内容。如果需要的话，添加功能应该很简单。

public IEnumerable<string> PropertyPath<TModel, TValue>(
    Expression<Func<TModel, TValue>> expression)
{
    if (expression.Body is MemberExpression memberExpression)
        return PropertyPathRecurse(memberExpression);
        
    return Enumerable.Empty<string>();
}

private IEnumerable<string> PropertyPathRecurse(MemberExpression? expression)
{
    if (expression is null)
        return Enumerable.Empty<string>();
        
    return PropertyPathRecurse(expression.Expression as MemberExpression)
        .Append(expression.Member.Name);
}