如何使用表达式树安全地访问可空对象的路径

本文关键字：对象 路径 访问 何使用 表达式 安全 | 更新日期: 2023-09-27 17:51:01

当我得到反序列化的XML结果到xsd生成的对象树中，并希望在该树中使用一些深层对象时，如果该查询路径上的任何节点缺失，它将给我异常。

if(a.b.c.d.e.f != null)
    Console.Write("ok");

我想避免像这样检查每个级别是否为空:

if(a != null)
if(a.b != null)
if(a.b.c != null)
if(a.b.c.d != null)
if(a.b.c.d.e != null)
if(a.b.c.d.e.f != null)
    Console.Write("ok");

第一个解决方案是实现Get扩展方法，允许:

if(a.Get(o=>o.b).Get(o=>o.c).Get(o=>o.d).Get(o=>o.e).Get(o=>o.f) != null)
    Console.Write("ok");

第二个解决方案是实现Get(string)扩展方法，并使用反射来获得如下结果:

if(a.Get("b.c.d.e.f") != null)
    Console.Write("ok");

第三个解决方案，可能是实现ExpandoObject并使用动态类型来获得如下结果:

dynamic da = new SafeExpando(a);
if(da.b.c.d.e.f != null)
    Console.Write("ok");

但是最后两个解决方案并没有提供强类型和智能感知的好处。

我认为最好的可能是可以用表达式树实现的第四个解决方案:

if(Get(a.b.c.d.e.f) != null)
    Console.Write("ok");

或

if(a.Get(a=>a.b.c.d.e.f) != null)
    Console.Write("ok");

我已经实现了第一个和第二个解决方案。

第一个解是这样的:

[DebuggerStepThrough]
public static To Get<From,To>(this From @this, Func<From,To> get)
{
    var ret = default(To);
    if(@this != null && !@this.Equals(default(From)))
        ret = get(@this);
    if(ret == null && typeof(To).IsArray)
        ret = (To)Activator.CreateInstance(typeof(To), 0);
    return ret;
}

如果可能，如何实施第四个解决方案?

如果可能的话，看看如何实现第三种解决方案会很有趣。

如何使用表达式树安全地访问可空对象的路径

首先创建一个表达式访问器。这使我们能够找到特定表达式中的所有成员访问。这就给我们留下了一个问题:对于每个成员访问应该做些什么?

所以第一件事是递归访问被访问成员的表达式。从那里，我们可以使用Expression.Condition来创建一个条件块，将处理后的底层表达式与null进行比较，如果为真则返回null，如果不为真则返回原始开始表达式。

请注意，我们需要为成员和方法调用提供实现，但两者的过程基本相同。

我们还将添加一个检查，以便底层表达式是null(也就是说，没有实例，它是一个静态成员)，或者如果它是一个非空类型，我们只使用基本行为代替。

public class MemberNullPropogationVisitor : ExpressionVisitor
{
    protected override Expression VisitMember(MemberExpression node)
    {
        if (node.Expression == null || !IsNullable(node.Expression.Type))
            return base.VisitMember(node);
        var expression = base.Visit(node.Expression);
        var nullBaseExpression = Expression.Constant(null, expression.Type);
        var test = Expression.Equal(expression, nullBaseExpression);
        var memberAccess = Expression.MakeMemberAccess(expression, node.Member);
        var nullMemberExpression = Expression.Constant(null, node.Type);
        return Expression.Condition(test, nullMemberExpression, node);
    }
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Object == null || !IsNullable(node.Object.Type))
            return base.VisitMethodCall(node);
        var expression = base.Visit(node.Object);
        var nullBaseExpression = Expression.Constant(null, expression.Type);
        var test = Expression.Equal(expression, nullBaseExpression);
        var memberAccess = Expression.Call(expression, node.Method);
        var nullMemberExpression = Expression.Constant(null, MakeNullable(node.Type));
        return Expression.Condition(test, nullMemberExpression, node);
    }
    private static Type MakeNullable(Type type)
    {
        if (IsNullable(type))
            return type;
        return typeof(Nullable<>).MakeGenericType(type);
    }
    private static bool IsNullable(Type type)
    {
        if (type.IsClass)
            return true;
        return type.IsGenericType &&
            type.GetGenericTypeDefinition() == typeof(Nullable<>);
    }
}
然后，我们可以创建一个扩展方法，使调用更容易: 
public static Expression PropogateNull(this Expression expression)
{
    return new MemberNullPropogationVisitor().Visit(expression);
}

也可以接受lambda，而不是任何表达式，并且可以返回编译委托:

public static Func<T> PropogateNull<T>(this Expression<Func<T>> expression)
{
    var defaultValue = Expression.Constant(default(T));
    var body = expression.Body.PropogateNull();
    if (body.Type != typeof(T))
        body = Expression.Coalesce(body, defaultValue);
    return Expression.Lambda<Func<T>>(body, expression.Parameters)
        .Compile();
}

注意，为了支持被访问的成员解析为非空值的情况，我们使用MakeNullable改变了这些表达式的类型，将它们提升为可空值。这是这个最终表达式的问题，因为它需要是Func<T>，如果T也没有解除，它将不匹配。因此，虽然它非常不理想(理想情况下，您永远不会使用非空的T调用此方法，但在c#中没有很好的方法来支持这一点)，但如果有必要，我们使用该类型的默认值合并最终值。

(您可以简单地将其修改为接受接受参数的lambda，并传入一个值，但您也可以很容易地关闭该参数，因此我认为没有真正的理由。)

同样值得指出的是，在c# 6.0中，当它实际发布时，我们将有一个实际的空传播操作符(?.)，使所有这些都变得非常不必要。你可以这样写:

if(a?.b?.c?.d?.e?.f != null)
    Console.Write("ok");
相关文章：