如何将任意lambda作为参数传递给函数（以获取命名层次结构）？

Question

我有一些（我认为是...）被MemberExpression包装的MemberExpression。

void Main()
{
    Foo<Person>(x => x.Name, x => x.Id, x => x.Address);
}

void Foo<TSource>(params Expression<Func<TSource, TValue>>[] lambdas)
{
    foreach (var lambda in lambdas)
    {
        Console.WriteLine(GetHierarchicalName(lambda));
    }
}

string GetHierarchicalName<TSource, TValue>(Expression<Func<TSource, TValue>> lambda)
{
    var member = lambda.Body as MemberExpression;
    var hierarchy = new Stack<string>();

    if (member == null)
    {
        throw new ArgumentException("You need to pass a lambda which references a member, silly!");
    }

    do
    {
        hierarchy.Push(member.Member.Name);
    } while (member.Expression.NodeType == ExpressionType.MemberAccess && (member = member.Expression as MemberExpression) != null);

    return String.Join("", hierarchy.ToArray());
}

我的最终目标是Foo将输出“名称”，“ Id”和“地址”（此外，当传递诸如x => x.Foo.Bar.Baz类的lambda时，将输出“ FooBarBaz”）。

但是，目前我没有为Foo指定TValue ； 我不能，因为每个lambda都可以返回不同的值... 但是我不在乎，因为我需要的只是它们所引用的属性路径。

我尝试使用object代替TValue ，但是当lambda返回一个int ，传递给GetHierarchicalName的lambda最终将是Convert而不是MemberExpression 。

如何避免不指定TValue ，以便可以将任意lambda传递给Foo() ，并让其将路径输出到每个lambda所引用的成员？

Answer 1

需要将int值装箱以表示为对象，这就是为什么要获取Convert表达式的原因。 您必须获取Convert表达式的Operand而不是Body ：

    var member = lambda.Body as MemberExpression;
    if (member == null && lambda.Body is UnaryExpression && lambda.Body.NodeType == ExpressionType.Convert)
    {
       member = (lambda.Body as UnaryExpression).Operand as MemberExpression;
    }

Answer 2

您必须声明一堆形式为Foo<TSource, T1, ..., TN>重载，类似于Action和Func自身如何对多达16个参数重载。 例如：

void Foo<TSource, T1, T2, T3>(Expression<Func<TSource, T1>> m1, Expression<Func<TSource, T2>> m2, Expression<Func<TSource, T3>> m3)
{
    Console.WriteLine(GetHierarchicalName(m1));
    Console.WriteLine(GetHierarchicalName(m2));
    Console.WriteLine(GetHierarchicalName(m3));
}

这可以称为：

Foo<string, int, string>(x => x.Name, x => x.Id, x => x.Address);

为了使编译器可以推断类型，Foo必须接受类型为TSource的额外参数：

Foo<TSource, T1, T2, T3>(TSource source, Expression<Func<TSource, T1>> m1, ...) { ... }

因此可以称为：

Foo(person, x => x.Name, x => x.Id, x => x.Address);

但是，所有这些工作都是徒劳的。

转换由具有NodeType ExpressionType.Convert的UnaryExpression ExpressionType.Convert 。 在这种情况下，其Operand属性包含您要查找的MemberExpression 。

Answer 3

您需要一些可以与任何表达式一起编码的代码，无需指定它是类型化表达式，因此您可以仅使用基本Expression类。

这是我使用的实用程序类中的一些代码，其中包含一些代码来处理Converts并将其删除。 请注意，我是在LinqPad中编写的，因此如果要在其他位置运行Dump（），则可能需要使用Console.WriteLine之类的东西来替换它。

    void Main()
    {               
        Foo(x => x.Name, x => x.Id, x => x.Address);
    }

    void Foo(params Expression<Func<Bar, object>>[] lambdas)
    {
        foreach (var lambda in lambdas)
        {
            ExpressionToString(lambda).Dump();
        }
    }

    public static string ExpressionToString(Expression selector)
    {
        string left, right, result;
        switch (selector.NodeType)
        {
            case ExpressionType.MemberAccess:
                var memberExpression = selector as MemberExpression;
                right = (memberExpression.Member as PropertyInfo).Name;
                if (memberExpression.Expression.NodeType == ExpressionType.MemberAccess)
                {
                    left = ExpressionToString(memberExpression.Expression);
                    result = left + right;
                }
                else
                {
                    result = right;
                }

                break;
            case ExpressionType.Call:
                var method = selector as MethodCallExpression;
                left = ExpressionToString(method.Arguments[0]);
                right = ExpressionToString(method.Arguments[1]);
                result = left + right;
                break;
            case ExpressionType.Lambda:
                var lambda = selector as LambdaExpression;
                result = ExpressionToString(lambda.Body);
                break;
            case ExpressionType.Quote:
            case ExpressionType.Convert:
                var unary = selector as UnaryExpression;
                result = ExpressionToString(unary.Operand);
                break;
            default:
                throw new InvalidOperationException("Expression must be MemberAccess, Call, Quote, Convert or Lambda");
        }

        return result;
    }

    public class Bar
    {
        public String Name { get; set; }

        public String Id { get; set; }

        public String Address { get; set; }
    }

这将产生：

Name    
Id    
Address