[C#] 깊은 null 검사, 더 좋은 방법이 있습니까?

이 질문에서 영감을 얻어 식 트리를 사용하여 더 쉽고 더 예쁘게 구문을 사용하여 이러한 종류의 깊은 null 검사를 수행하는 방법을 알아 냈습니다. 계층 구조의 깊은 인스턴스에 액세스해야하는 경우 디자인이 잘못 될 수 있다는 답변에 동의하지만 데이터 표시와 같은 경우에는 매우 유용 할 수 있다고 생각합니다.

그래서 확장 메소드를 만들었습니다.

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

표현식의 일부가 null이 아닌 경우 Berries를 반환합니다. null이 있으면 null이 반환됩니다. 그러나 현재 버전에서는 간단한 멤버 액세스에서만 작동하며 v4의 새로운 MemberExpression.Update 메서드를 사용하기 때문에 .NET Framework 4에서만 작동합니다. 다음은 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;
        }
    }
}

그것은 당신의 표현을 나타내는 표현 트리를 검사하고 부품을 차례로 평가함으로써 작동합니다. 결과가 null이 아닌지 확인할 때마다

MemberExpression 이외의 다른 표현식이 지원되도록 이것을 확장 할 수 있다고 확신합니다. 이것을 개념 증명 코드로 생각하고 그것을 사용하면 성능이 저하 될 수 있음을 명심하십시오 (아마도 많은 경우 중요하지 않지만 단단한 루프에서는 사용하지 마십시오 :-))

답변

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

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

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

try
{
    var x = cake.frosting.berries.loader;
    ...
}
catch (NullReferenceException ex)
{
    // either one of cake, frosting, or berries was 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" );

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

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;
    }