Comprobación nula profunda, ¿hay una mejor manera?

Nota: Esta pregunta se hizo antes de la introducción del .?operador en C # 6 / Visual Studio 2015 .

Todos hemos estado allí, tenemos algunas propiedades profundas como cake.frosting.berries.loader que debemos verificar si es nula para que no haya ninguna excepción. La forma de hacerlo es usar una declaración if de cortocircuito

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

Esto no es exactamente elegante, y quizás debería haber una forma más fácil de verificar toda la cadena y ver si se encuentra con una variable / propiedad nula.

¿Es posible usar algún método de extensión o sería una característica del lenguaje, o es solo una mala idea?

Hemos considerado agregar una nueva operación "?" al lenguaje que tiene la semántica que deseas. (Y se ha agregado ahora; ver más abajo). Es decir, dirías

cake?.frosting?.berries?.loader

y el compilador generaría todas las comprobaciones de cortocircuito por usted.

No hizo la barra para C # 4. Tal vez para una futura versión hipotética del lenguaje.

Actualización (2014): El ?.operador ahora está planeado para la próxima versión del compilador de Roslyn. Tenga en cuenta que todavía hay cierto debate sobre el análisis sintáctico y semántico exacto del operador.

Actualización (julio de 2015): Visual Studio 2015 se lanzó y se entrega con un compilador de C # que admite los operadores ?.y condicional nulo?[] .

Esta pregunta me inspiró para tratar de descubrir cómo se puede realizar este tipo de comprobación nula profunda con una sintaxis más fácil / bonita utilizando árboles de expresión. Si bien estoy de acuerdo con las respuestas que indican que podría ser un mal diseño si a menudo necesita acceder a instancias en lo profundo de la jerarquía, también creo que en algunos casos, como la presentación de datos, puede ser muy útil.

Así que creé un método de extensión, que te permitirá escribir:

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

Esto devolverá las Bayas si ninguna parte de la expresión es nula. Si se encuentra nulo, se devuelve nulo. Sin embargo, hay algunas advertencias, en la versión actual solo funcionará con acceso simple de miembros, y solo funciona en .NET Framework 4, porque usa el método MemberExpression.Update, que es nuevo en v4. Este es el código para el método de extensión 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;            
        }
    }
}

Funciona examinando el árbol de expresión que representa su expresión y evaluando las partes una tras otra; cada vez comprobando que el resultado no es nulo.

Estoy seguro de que esto podría extenderse para que otras expresiones que no sean MemberExpression sean compatibles. Considere esto como un código de prueba de concepto, y tenga en cuenta que habrá una penalización de rendimiento al usarlo (lo que probablemente no importará en muchos casos, pero no lo use en un ciclo cerrado :-))

He encontrado que esta extensión es bastante útil para escenarios de anidación profunda.

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

Es una idea que obtuve del operador de fusión nula en C # y T-SQL. Lo bueno es que el tipo de retorno es siempre el tipo de retorno de la propiedad interna.

De esa manera puedes hacer esto:

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

... o una ligera variación de lo anterior:

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

No es la mejor sintaxis que conozco, pero funciona.

Además de violar la Ley de Deméter, como ya ha señalado Mehrdad Afshari, me parece que necesita una "verificación nula profunda" para la lógica de decisión.

Este suele ser el caso cuando desea reemplazar objetos vacíos con valores predeterminados. En este caso, debería considerar implementar el Patrón de objetos nulos . Actúa como un sustituto de un objeto real, proporcionando valores predeterminados y métodos de "no acción".

Actualización: a partir de Visual Studio 2015, el compilador de C # (versión de lenguaje 6) ahora reconoce al ?.operador, lo que hace que la "comprobación nula profunda" sea muy sencilla. Ver esta respuesta para más detalles.

Además de rediseñar su código, como sugiere esta respuesta eliminada , otra opción (aunque terrible) sería usar un try…catchbloque para ver si NullReferenceExceptionocurre en algún momento durante esa búsqueda profunda de propiedades.

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

Yo personalmente no haría esto por las siguientes razones:

• No se ve bien.
• Utiliza el manejo de excepciones, que debe enfocarse en situaciones excepcionales y no en algo que usted espera que suceda a menudo durante el curso normal de la operación.
• NullReferenceExceptions probablemente nunca debería ser atrapado explícitamente. (Ver esta pregunta )

Entonces, ¿es posible usar algún método de extensión o sería una función de idioma, [...]

Es casi seguro que tendría que ser una función de lenguaje (que está disponible en C # 6 en forma de .?y?[] operadores), a menos que C # ya tenía más sofisticado evaluación perezosa, o menos que desee utilizar la reflexión (que probablemente no es también una buena idea por razones de rendimiento y seguridad de tipo).

Como no hay forma de pasar simplemente cake.frosting.berries.loadera una función (se evaluaría y arrojaría una excepción de referencia nula), tendría que implementar un método de búsqueda general de la siguiente manera: toma objetos y los nombres de propiedades para buscar:

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" );

(Nota: código editado).

Rápidamente ve varios problemas con este enfoque. Primero, no obtienes ningún tipo de seguridad y posible boxeo de valores de propiedad de un tipo simple. En segundo lugar, puede regresar nullsi algo sale mal, y tendrá que verificar esto en su función de llamada, o lanzará una excepción y volverá a donde comenzó. Tercero, puede ser lento. Cuarto, parece más feo de lo que comenzaste.

[...], ¿o es solo una mala idea?

O me quedaría con:

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

o vaya con la respuesta anterior de Mehrdad Afshari.

PD: Cuando escribí esta respuesta, obviamente no consideraba los árboles de expresión para las funciones lambda; vea, por ejemplo, la respuesta de @driis para una solución en esta dirección. También se basa en un tipo de reflexión y, por lo tanto, podría no funcionar tan bien como una solución más simple ( if (… != null & … != null) …), pero puede considerarse mejor desde el punto de vista de la sintaxis.

Si bien la respuesta de driis es interesante, creo que es un rendimiento demasiado costoso. En lugar de compilar muchos delegados, preferiría compilar una lambda por ruta de propiedad, almacenarla en caché y luego volver a invocarla en muchos tipos.

NullCoalesce a continuación hace exactamente eso, devuelve una nueva expresión lambda con comprobaciones nulas y un retorno de default (TResult) en caso de que alguna ruta sea nula.

Ejemplo:

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

Devolverá una expresión

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

Código:

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

Una opción es usar el Patten de objetos nulos, así que en lugar de tener null cuando no tienes un pastel, tienes un NullCake que devuelve un NullFosting, etc. Lo siento, no soy muy bueno para explicar esto, pero otras personas lo son, mira

• Un ejemplo del uso de Patten de objetos nulos
• Los wikipedai escriben sobre el objeto nulo Patten

¡Yo también he deseado a menudo una sintaxis más simple! Se vuelve especialmente feo cuando tienes valores de retorno de método que pueden ser nulos, porque entonces necesitas variables adicionales (por ejemplo:cake.frosting.flavors.FirstOrDefault().loader )

Sin embargo, aquí hay una alternativa bastante decente que utilizo: crear un método auxiliar Null-Safe-Chain. Me doy cuenta de que esto es bastante similar a la respuesta de @ John anterior (con el Coalmétodo de extensión), pero creo que es más sencillo y menos tipeado. Así es como se ve:

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

Aquí está la implementación:

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

También creé varias sobrecargas (con 2 a 6 parámetros), así como sobrecargas que permiten que la cadena termine con un tipo de valor o predeterminado. ¡Esto funciona muy bien para mí!

Hay un proyecto tal vez codeplex que implementa Quizás o IfNotNull usando lambdas para expresiones profundas en C #

Ejemplo de uso:

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

El enlace se sugirió en una pregunta similar ¿ Cómo verificar nulos en una expresión lambda profunda?

Como se sugiere en la respuesta de John Leidegren , un enfoque para evitar esto es utilizar métodos de extensión y delegados. Usarlos podría verse más o menos así:

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

La implementación es desordenada porque necesita que funcione para los tipos de valor, los tipos de referencia y los tipos de valores anulables. Puede encontrar una implementación completa en la respuesta de Timwi a ¿Cuál es la forma correcta de verificar los valores nulos? .

O puedes usar la reflexión :)

Función de reflexión:

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

Uso:

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

Mi caso (devuelve DBNull.Value en lugar de nulo en la función de reflexión):

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

Prueba este código:

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

Publiqué esto anoche y luego un amigo me señaló esta pregunta. Espero eso ayude. Entonces puedes hacer algo como esto:

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

Lea la publicación completa del blog aquí .

El mismo amigo también sugirió que veas esto .

Modifiqué ligeramente el código desde aquí para que funcione para la pregunta que se hace:

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

Y sí, probablemente esta no sea la solución óptima debido a las implicaciones de rendimiento de prueba / captura, pero funciona:>

Uso:

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

Donde necesites lograr esto, haz esto:

Uso

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

o

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

Implementación de clase auxiliar

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

Me gusta el enfoque adoptado por Objective-C:

"El lenguaje Objective-C adopta otro enfoque para este problema y no invoca métodos en nulo, sino que devuelve nulo para todas esas invocaciones".

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