处理可能包含空值的属性链

Question

我有一些代码在长属性链的末尾提取一个值，其中任何一个属性都可能为空。

例如：

var value = prop1.prop2.prop3.prop4;

为了处理 prop1 中 null 的可能性，我必须写：

var value = prop1 == null ? null : prop1.prop2.prop3.prop4;

为了处理 prop1 和 prop2 中 null 的可能性，我必须写：

var value = prop1 == null 
            ? null 
            : prop1.prop2 == null ? null : prop1.prop2.prop3.prop4;

或

var value = prop1 != null && prop1.prop2 != null 
            ? prop1.prop2.prop3.prop4 
            : null;

如果我想处理这种可能性如果 prop1、prop2 和 prop3 中也存在 null，甚至更长的属性链，那么代码就会开始变得非常疯狂。

必须有更好的方法来做到这一点。

如何处理属性链，以便在遇到 null 时返回 null？

像 ?? 这样的东西运营商会很棒。

Answer 1

更新

从 C# 6 开始，解决方案现已融入到该语言中 空条件运算符; ?. 用于属性，?[n] 用于索引器。

空条件运算符允许您访问成员和元素
仅当接收者不为空时，否则提供空结果：

<前><代码>int？长度=客户？.长度； // 如果客户为空，则为空
客户至上 = 客户？[0]; // 如果客户为空，则为空

---

旧答案

我查看了那里的不同解决方案。其中一些使用将多个扩展方法调用链接在一起，我不喜欢这种做法，因为由于每个链添加的噪音量，它的可读性不太好。

我决定使用仅涉及单个扩展方法调用的解决方案，因为它更具可读性。我还没有测试性能，但就我而言，可读性比性能更重要。

我创建了以下类，松散地基于 此解决方案

public static class NullHandling
{
    /// <summary>
    /// Returns the value specified by the expression or Null or the default value of the expression's type if any of the items in the expression
    /// return null. Use this method for handling long property chains where checking each intermdiate value for a null would be necessary.
    /// </summary>
    /// <typeparam name="TObject"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="instance"></param>
    /// <param name="expression"></param>
    /// <returns></returns>
    public static TResult GetValueOrDefault<TObject, TResult>(this TObject instance, Expression<Func<TObject, TResult>> expression) 
        where TObject : class
    {
        var result = GetValue(instance, expression.Body);

        return result == null ? default(TResult) : (TResult) result;
    }

    private static object GetValue(object value, Expression expression)
    {
        object result;

        if (value == null) return null;

        switch (expression.NodeType)
        {
            case ExpressionType.Parameter:
                return value;

            case ExpressionType.MemberAccess:
                var memberExpression = (MemberExpression)expression;
                result = GetValue(value, memberExpression.Expression);

                return result == null ? null : GetValue(result, memberExpression.Member);

            case ExpressionType.Call:
                var methodCallExpression = (MethodCallExpression)expression;

                if (!SupportsMethod(methodCallExpression))
                    throw new NotSupportedException(methodCallExpression.Method + " is not supported");

                result = GetValue(value, methodCallExpression.Method.IsStatic
                                             ? methodCallExpression.Arguments[0]
                                             : methodCallExpression.Object);
                return result == null
                           ? null
                           : GetValue(result, methodCallExpression.Method);

            case ExpressionType.Convert:
                var unaryExpression = (UnaryExpression) expression;

                return Convert(GetValue(value, unaryExpression.Operand), unaryExpression.Type);

            default:
                throw new NotSupportedException("{0} not supported".FormatWith(expression.GetType()));
        }
    }

    private static object Convert(object value, Type type)
    {
        return Expression.Lambda(Expression.Convert(Expression.Constant(value), type)).Compile().DynamicInvoke();
    }

    private static object GetValue(object instance, MemberInfo memberInfo)
    {
        switch (memberInfo.MemberType)
        {
            case MemberTypes.Field:
                return ((FieldInfo)memberInfo).GetValue(instance);
            case MemberTypes.Method:
                return GetValue(instance, (MethodBase)memberInfo);
            case MemberTypes.Property:
                return GetValue(instance, (PropertyInfo)memberInfo);
            default:
                throw new NotSupportedException("{0} not supported".FormatWith(memberInfo.MemberType));
        }
    }

    private static object GetValue(object instance, PropertyInfo propertyInfo)
    {
        return propertyInfo.GetGetMethod(true).Invoke(instance, null);
    }

    private static object GetValue(object instance, MethodBase method)
    {
        return method.IsStatic
                   ? method.Invoke(null, new[] { instance })
                   : method.Invoke(instance, null);
    }

    private static bool SupportsMethod(MethodCallExpression methodCallExpression)
    {
        return (methodCallExpression.Method.IsStatic && methodCallExpression.Arguments.Count == 1) || (methodCallExpression.Arguments.Count == 0);
    }
}

这允许我编写以下内容：

var x = scholarshipApplication.GetValueOrDefault(sa => sa.Scholarship.CostScholarship.OfficialCurrentWorldRanking);

x 将包含 scholarshipApplication.Scholarship.CostScholarship.OfficialCurrentWorldRanking 或 的值null 如果链中的任何属性一路返回 null。

Answer 2

我使用 IfNotNull 扩展方法 来处理这个问题。

它不是世界上最漂亮的东西（如果我看到它有 4 层深，我会有点害怕），但它适用于较小的情况。