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

所以第一件事就是以递归方式访问正在访问该成员的表达式.从那里,我们可以使用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,nullBaseExpression);
        var memberAccess = Expression.Call(expression,node.Method);
        var nullMemberExpression = Expression.Constant(null,MakeNullable(node.Type));
        return Expression.Condition(test,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中,当它实际发布时,我们将有一个实际的null传播运算符(？.),这使得所有这些都非常不必要.你可以写：

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

并且具有您正在寻找的语义.