深空检查，有没有更好的方法？

注意：这个问题是在引进之前问了.?用C＃操作6 /的Visual Studio 2015年。

我们都去过那里，我们有一些很深的属性，例如cake.frosting.berries.loader，我们需要检查它是否为null，所以也不例外。要做的方法是使用短路if语句

if (cake != null && cake.frosting != null && cake.frosting.berries != null) ...

这并不十分优雅，也许应该有一种更简单的方法来检查整个链，看看它是否与空变量/属性相抵触。

是否可以使用某些扩展方法，或者它是语言功能，还是一个坏主意？

我们考虑过添加一个新的操作“？”。具有所需语义的语言。（现在已添加；请参见下文。）也就是说，您会说

cake?.frosting?.berries?.loader

编译器将为您生成所有短路检查。

它并没有成为C＃4的标准。也许是该语言的一个假设的未来版本。

更新（2014年）： 该?.操作员现已计划用于下一个Roslyn编译器版本。请注意，关于运算符的确切语法和语义分析仍存在一些争论。

更新（2015年7月）： Visual Studio 2015已发布，并附带支持空条件运算符?.和?[]的C＃编译器。

我从这个问题中得到启发，尝试找出如何使用表达式树以更简单/更漂亮的语法完成这种深度的空检查。尽管我确实同意回答，指出如果您经常需要访问层次结构中的深层实例，这可能是一个糟糕的设计，但我也确实认为，在某些情况下，例如数据表示，它可能非常有用。

因此，我创建了一个扩展方法，该方法允许您编写：

var berries = cake.IfNotNull(c => c.Frosting.Berries);

如果表达式的任何部分都不为null，则将返回Berries。如果遇到null，则返回null。但是，有一些警告，在当前版本中，它仅适用于简单的成员访问，并且仅适用于.NET Framework 4，因为它使用了v4中新增的MemberExpression.Update方法。这是IfNotNull扩展方法的代码：

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace dr.IfNotNullOperator.PoC
{
    public static class ObjectExtensions
    {
        public static TResult IfNotNull<TArg,TResult>(this TArg arg, Expression<Func<TArg,TResult>> expression)
        {
            if (expression == null)
                throw new ArgumentNullException("expression");

            if (ReferenceEquals(arg, null))
                return default(TResult);

            var stack = new Stack<MemberExpression>();
            var expr = expression.Body as MemberExpression;
            while(expr != null)
            {
                stack.Push(expr);
                expr = expr.Expression as MemberExpression;
            } 

            if (stack.Count == 0 || !(stack.Peek().Expression is ParameterExpression))
                throw new ApplicationException(String.Format("The expression '{0}' contains unsupported constructs.",
                                                             expression));

            object a = arg;
            while(stack.Count > 0)
            {
                expr = stack.Pop();
                var p = expr.Expression as ParameterExpression;
                if (p == null)
                {
                    p = Expression.Parameter(a.GetType(), "x");
                    expr = expr.Update(p);
                }
                var lambda = Expression.Lambda(expr, p);
                Delegate t = lambda.Compile();                
                a = t.DynamicInvoke(a);
                if (ReferenceEquals(a, null))
                    return default(TResult);
            }

            return (TResult)a;            
        }
    }
}

它通过检查代表您的表情的表情树，然后一个接一个地评估各个部分来工作。每次检查结果都不为空。

我确定可以扩展它，以便支持除MemberExpression之外的其他表达式。将其视为概念验证代码，并请记住，使用它会降低性能（在许多情况下这可能无关紧要，但不要在紧密循环中使用它:-)）

我发现此扩展对于深度嵌套方案非常有用。

public static R Coal<T, R>(this T obj, Func<T, R> f)
    where T : class
{
    return obj != null ? f(obj) : default(R);
}

我是从C＃和T-SQL中的空合并运算符派生的。令人高兴的是，返回类型始终是内部属性的返回类型。

这样，您可以执行以下操作：

var berries = cake.Coal(x => x.frosting).Coal(x => x.berries);

...或上述内容的细微变化：

var berries = cake.Coal(x => x.frosting, x => x.berries);

这不是我所知道的最好的语法，但是确实可以。

正如Mehrdad Afshari指出的那样，除了违反Demeter法则之外，在我看来，您还需要“深度null检查”来确定决策逻辑。

当您想用默认值替换空对象时，通常是这种情况。在这种情况下，您应该考虑实现Null对象模式。它充当真实对象的替代者，提供默认值和“非操作”方法。

更新：从Visual Studio 2015开始，C＃编译器（语言版本6）现在可以识别?.运算符，从而使“深度null检查”变得轻而易举。有关详细信息，请参见此答案。

除了重新设计代码（如 建议的已删除答案）外，另一个（虽然很糟糕）的选择是使用一个try…catch块来查看NullReferenceException在深层属性查找期间是否发生了错误。

try
{
    var x = cake.frosting.berries.loader;
    ...
}
catch (NullReferenceException ex)
{
    // either one of cake, frosting, or berries was null
    ...
}

由于以下原因，我个人不会这样做：

• 看起来不太好。
• 它使用异常处理，该异常处理应针对特殊情况，而不是您在正常操作过程中经常发生的异常。
• NullReferenceException可能永远都不应明确捕获。（请参阅此问题。）

因此，可以使用某些扩展方法还是它是一种语言功能，[...]

几乎可以肯定这必须是语言功能（在C＃6中以.?and ?[]运算符的形式提供），除非C＃已经具有更复杂的惰性求值，或者除非您要使用反射（这可能也不是反射功能）。基于性能和类型安全性的好主意）。

由于没有方法可以简单地传递cake.frosting.berries.loader给函数（该函数将被评估并引发null引用异常），因此您将必须通过以下方式实现常规查找方法：它接受一个对象和属性名称以抬头：

static object LookupProperty( object startingPoint, params string[] lookupChain )
{
    // 1. if 'startingPoint' is null, return null, or throw an exception.
    // 2. recursively look up one property/field after the other from 'lookupChain',
    //    using reflection.
    // 3. if one lookup is not possible, return null, or throw an exception.
    // 3. return the last property/field's value.
}

...

var x = LookupProperty( cake, "frosting", "berries", "loader" );

（注意：代码已编辑。）

您很快就会发现使用这种方法的几个问题。首先，您不会获得任何类型安全性，也不会获得简单类型的属性值的装箱。其次，null如果出现问题，则可以返回，并且必须在调用函数中进行检查，或者引发异常，然后返回到开始的地方。第三，它可能很慢。第四，它看起来比开始时要难看。

[...]还是一个坏主意？

我要么留在：

if (cake != null && cake.frosting != null && ...) ...

或采用Mehrdad Afshari的上述答案。

PS：回到我写这个答案时，我显然没有考虑将表达式树用于lambda函数。参见例如@driis的答案，以寻求该方向的解决方案。它也是基于一种反射，因此可能不如简单的解决方案（if (… != null & … != null) …）表现出色，但从语法角度来看可能会更好。

尽管driis的答案很有趣，但我认为这在性能上有点太昂贵了。我不想编译许多委托，而是更愿意为每个属性路径编译一个lambda，将其缓存，然后重新调用它许多类型。

下面的NullCoalesce就是这样做的，它返回带有空检查的新lambda表达式，并在任何路径为空的情况下返回default（TResult）。

例：

NullCoalesce((Process p) => p.StartInfo.FileName)

将返回一个表达式

(Process p) => (p != null && p.StartInfo != null ? p.StartInfo.FileName : default(string));

码：

    static void Main(string[] args)
    {
        var converted = NullCoalesce((MethodInfo p) => p.DeclaringType.Assembly.Evidence.Locked);
        var converted2 = NullCoalesce((string[] s) => s.Length);
    }

    private static Expression<Func<TSource, TResult>> NullCoalesce<TSource, TResult>(Expression<Func<TSource, TResult>> lambdaExpression)
    {
        var test = GetTest(lambdaExpression.Body);
        if (test != null)
        {
            return Expression.Lambda<Func<TSource, TResult>>(
                Expression.Condition(
                    test,
                    lambdaExpression.Body,
                    Expression.Default(
                        typeof(TResult)
                    )
                ),
                lambdaExpression.Parameters
            );
        }
        return lambdaExpression;
    }

    private static Expression GetTest(Expression expression)
    {
        Expression container;
        switch (expression.NodeType)
        {
            case ExpressionType.ArrayLength:
                container = ((UnaryExpression)expression).Operand;
                break;
            case ExpressionType.MemberAccess:
                if ((container = ((MemberExpression)expression).Expression) == null)
                {
                    return null;
                }
                break;
            default:
                return null;
        }
        var baseTest = GetTest(container);
        if (!container.Type.IsValueType)
        {
            var containerNotNull = Expression.NotEqual(
                container,
                Expression.Default(
                    container.Type
                )
            );
            return (baseTest == null ?
                containerNotNull :
                Expression.AndAlso(
                    baseTest,
                    containerNotNull
                )
            );
        }
        return baseTest;
    }

一种选择是使用Null Object Patten，因此，当您没有蛋糕时，您可以使用NullCake而不是null，该NullCake返回NullFosting等。对不起，我不太善于解释这一点，但是其他人可以看到

• 空对象彭定康用法的一个示例
• 维基百科在Null Object Patten上写下

我也经常希望使用更简单的语法！当你有方法返回值可能是零它变得特别难看，因为那么你需要额外的变量（例如：cake.frosting.flavors.FirstOrDefault().loader）

但是，这里有一个不错的替代方法：创建一个Null-Safe-Chain辅助方法。我意识到这与上面@John的答案（使用Coal扩展方法）非常相似，但是我发现它更简单，输入更少。看起来是这样的：

var loader = NullSafe.Chain(cake, c=>c.frosting, f=>f.berries, b=>b.loader);

这是实现：

public static TResult Chain<TA,TB,TC,TResult>(TA a, Func<TA,TB> b, Func<TB,TC> c, Func<TC,TResult> r) 
where TA:class where TB:class where TC:class {
    if (a == null) return default(TResult);
    var B = b(a);
    if (B == null) return default(TResult);
    var C = c(B);
    if (C == null) return default(TResult);
    return r(C);
}

我还创建了几个重载（带有2到6个参数），以及允许链以value-type或default结尾的重载。这对我来说真的很好！

可能有一个Codeplex 项目，该项目使用Lambda来实现Maybe或IfNotNull用于C＃中的深层表达式

使用示例：

int? CityId= employee.Maybe(e=>e.Person.Address.City);

该链接是在类似的问题中提出的。如何检查深lambda表达式中的null？

正如John Leidegren的回答所建议的，一种解决方法是使用扩展方法和委托。使用它们可能看起来像这样：

int? numberOfBerries = cake
    .NullOr(c => c.Frosting)
    .NullOr(f => f.Berries)
    .NullOr(b => b.Count());

该实现比较麻烦，因为您需要使它适用于值类型，引用类型和可为空的值类型。你可以找到一个完整的实现Timwi的回答到什么是检查空值的正确方法？。

或者您可以使用反射:)

反射功能：

public Object GetPropValue(String name, Object obj)
    {
        foreach (String part in name.Split('.'))
        {
            if (obj == null) { return null; }

            Type type = obj.GetType();
            PropertyInfo info = type.GetProperty(part);
            if (info == null) { return null; }

            obj = info.GetValue(obj, null);
        }
        return obj;
    }

用法：

object test1 = GetPropValue("PropertyA.PropertyB.PropertyC",obj);

我的案例（在反射函数中返回DBNull.Value而不是null）：

cmd.Parameters.AddWithValue("CustomerContactEmail", GetPropValue("AccountingCustomerParty.Party.Contact.ElectronicMail.Value", eInvoiceType));

试试这个代码：

    /// <summary>
    /// check deep property
    /// </summary>
    /// <param name="obj">instance</param>
    /// <param name="property">deep property not include instance name example "A.B.C.D.E"</param>
    /// <returns>if null return true else return false</returns>
    public static bool IsNull(this object obj, string property)
    {
        if (string.IsNullOrEmpty(property) || string.IsNullOrEmpty(property.Trim())) throw new Exception("Parameter : property is empty");
        if (obj != null)
        {
            string[] deep = property.Split('.');
            object instance = obj;
            Type objType = instance.GetType();
            PropertyInfo propertyInfo;
            foreach (string p in deep)
            {
                propertyInfo = objType.GetProperty(p);
                if (propertyInfo == null) throw new Exception("No property : " + p);
                instance = propertyInfo.GetValue(instance, null);
                if (instance != null)
                    objType = instance.GetType();
                else
                    return true;
            }
            return false;
        }
        else
            return true;
    }

我昨晚发布了这个帖子，然后一个朋友向我指出了这个问题。希望能帮助到你。然后，您可以执行以下操作：

var color = Dis.OrDat<string>(() => cake.frosting.berries.color, "blue");


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace DeepNullCoalescence
{
  public static class Dis
  {
    public static T OrDat<T>(Expression<Func><T>> expr, T dat)
    {
      try
      {
        var func = expr.Compile();
        var result = func.Invoke();
        return result ?? dat; //now we can coalesce
      }
      catch (NullReferenceException)
      {
        return dat;
      }
    }
  }
}

在此处阅读完整的博客文章。

同一位朋友还建议您观看此影片。

我从这里稍微修改了代码，以使其适用于所提出的问题：

public static class GetValueOrDefaultExtension
{
    public static TResult GetValueOrDefault<TSource, TResult>(this TSource source, Func<TSource, TResult> selector)
    {
        try { return selector(source); }
        catch { return default(TResult); }
    }
}

是的，由于try / catch性能的影响，这可能不是最佳解决方案，但是它很有效：>

用法：

var val = cake.GetValueOrDefault(x => x.frosting.berries.loader);

在需要实现此目标的地方，请执行以下操作：

用法

Color color = someOrder.ComplexGet(x => x.Customer.LastOrder.Product.Color);

要么

Color color = Complex.Get(() => someOrder.Customer.LastOrder.Product.Color);

助手类的实现

public static class Complex
{
    public static T1 ComplexGet<T1, T2>(this T2 root, Func<T2, T1> func)
    {
        return Get(() => func(root));
    }

    public static T Get<T>(Func<T> func)
    {
        try
        {
            return func();
        }
        catch (Exception)
        {
            return default(T);
        }
    }
}

我喜欢Objective-C采取的​​方法：

“ Objective-C语言采用了另一种方法来解决此问题，并且不会在nil上调用方法，而是为所有此类调用返回nil。”

if (cake.frosting.berries != null) 
{
    var str = cake.frosting.berries...;
}