c# - 组合 lambda 表达式以检索嵌套值

Question

我正在尝试创建表达式来访问嵌套结构中的字段或属性。

我设法为平面对象上的字段和属性创建了 getter 和 setter(作为 lambda 表达式)。它是这样工作的:

Delegate getter = getGetterExpression(objectType,"PropertyOrFieldName").Compile();
Delegate setter = getSetterExpression(objectType,"PropertyorFieldName").Compile();

我找到了 this发布(Marc Gravells 回答)使用自定义表达式访问者“链接”那些 lambda 表达式以访问嵌套对象。如果您有一些深度(动态)嵌套，如以下示例代码，这是执行此操作的正确方法(通过链接 lambda 表达式)吗？还是有更有效的方法来实现这一点？

// 'regular' C# Code
obj.PropA.FieldB.FieldC.PropD = "Hello World";

// targeted 'expression approach'
Delegate setter  = GetPathSetterLambda(obj.GetType(), "PropA.FieldB.FieldC.PropD").Compile();
setter.DynamicInvoke(obj, "Hello World!");

getter 和 setter 是这样创建的:

private static LambdaExpression getSetterExpression(Type objectType, string fieldOrPropertyName)
{
    ParameterExpression parameterExpression = Expression.Parameter(objectType);
    MemberExpression memberExpression = Expression.PropertyOrField(parameterExpression, fieldOrPropertyName);

    ParameterExpression valueParameterExpression = Expression.Parameter(memberExpression.Type);
    BinaryExpression assignExpression = Expression.Assign(memberExpression, valueParameterExpression);

    Type setterType = typeof(Action<,>).MakeGenericType(objectType, memberExpression.Type);

    return Expression.Lambda(setterType, assignExpression, parameterExpression, valueParameterExpression);
}

private static LambdaExpression getGetterExpression(Type objectType, string fieldOrPropertyName)
{
    ParameterExpression parameterExpression = Expression.Parameter(objectType);
    MemberExpression memberExpression = Expression.PropertyOrField(parameterExpression, fieldOrPropertyName);

    Type getterType = typeof(Func<,>).MakeGenericType(objectType, memberExpression.Type);

    return Expression.Lambda(getterType, memberExpression, parameterExpression);
}

与使用反射相比，我尝试这样做主要是为了提高性能。

Answer 1

编译动态 lambda 表达式，因此您可以获得对象的直接访问器和修改器，这可能真的比重复反射来访问属性更有效。虽然表达式真的不应该像那样使用，但我下面的实现只是在内部使用它们来创建直接委托(delegate)来读取或设置值。

这是我想出来的。我确保不向外部公开任何表达式，而只是返回简单的委托(delegate)。由于 lambda 表达式的工作方式，它们需要我通过通用参数提供的基本类型。如果您在 Type 对象中只有运行时的类型，您可以轻松更改它，但您还必须更改委托(delegate)类型。我避免必须指定实际的属性类型。在访问器中，我只返回一个对象，对于增变器，我在表达式中进行类型转换。

public static Func<T, object> GetAccessor<T>(string path)
{
    ParameterExpression paramObj = Expression.Parameter(typeof(T), "obj");

    Expression body = paramObj;
    foreach (string property in path.Split('.'))
    {
        body = Expression.PropertyOrField(body, property);
    }

    return Expression.Lambda<Func<T, object>>(body, new ParameterExpression[] { paramObj }).Compile();
}

public static Action<T, object> GetMutator<T>(string path)
{
    ParameterExpression paramObj = Expression.Parameter(typeof(T), "obj");
    ParameterExpression paramValue = Expression.Parameter(typeof(object), "value");

    Expression body = paramObj;
    foreach(string property in path.Split('.'))
    {
        body = Expression.PropertyOrField(body, property);
    }

    body = Expression.Assign(body, Expression.TypeAs(paramValue, body.Type));
    return Expression.Lambda<Action<T, object>>(body, new ParameterExpression[] { paramObj, paramValue }).Compile();
}

实现可以这样使用:

obj.SomeB.SomeC.Foo = "bar";

var getter = GetAccessor<A>("SomeB.SomeC.Foo");
var setter = GetMutator<A>("SomeB.SomeC.Foo");

Console.WriteLine(getter(obj)); // "bar"
setter(obj, "baz");
Console.WriteLine(getter(obj)); // "baz"

至于错误，这两种方法都会在创建委托(delegate)时针对无效路径引发 ArgumentException。除此之外，我认为没有什么可以出错的。对于无效的类型，修改器将静默地将值设置为 null。

该解决方案目前不适用于值类型；您可能必须添加一些额外的类型转换才能使其工作——或者如果您可以接受，则为属性类型添加另一个类型参数。

原始答案

在这里使用表达式没有意义。表达式的全部意义在于具有实际 C# 语法，因此您拥有 IntelliSense、语法验证和类型安全。通过接受表达式的 strings，你做的恰恰相反，从中构建表达式并编译它们只是为了你可以访问 getter 和 setter 真的没有意义。

如果您有表示路径的字符串，那么您应该只使用标准反射。

一个示例实现(没有对无效属性名称或 NULL 值进行错误检测——你应该添加它!):

class PropertyAccessor
{
    private string[] properties;

    public PropertyAccessor (string path)
    {
        properties = path.Split('.');
    }

    private object GetValue (object obj, string property)
    {
        return obj.GetType().GetProperty(property).GetValue(obj);
    }

    private void SetValue (object obj, string property, object value)
    {
        return obj.GetType().GetProperty(property).SetValue(obj, value);
    }

    public object Get (object obj)
    {
        object o = obj;
        for (int i = 0; i < properties.Length; i++)
        {
            o = GetValue(o, properties[i]);
        }
        return o;
    }

    public void Set (object obj, object value)
    {
        object o = obj;
        for (int i = 0; i < properties.Length - 1; i++)
        {
            o = GetValue(o, properties[i]);
        }

        SetValue(o, properties[properties.Length - 1], value);
    }
}

这样使用:

obj.SomeB.SomeC.Foo = "bar";

var pa = new PropertyAccessor("SomeB.SomeC.Foo");

Console.WriteLine(pa.Get(obj)); // "bar"
pa.Set(obj, "baz");
Console.WriteLine(pa.Get(obj)); // "baz"