C # forma elegante de verificar si la propiedad de una propiedad es nula

En C #, diga que desea extraer un valor de PropertyC en este ejemplo y ObjectA, PropertyA y PropertyB pueden ser todos nulos.

ObjectA.PropertyA.PropertyB.PropertyC

¿Cómo puedo obtener PropertyC de forma segura con la menor cantidad de código?

Ahora mismo comprobaría:

if(ObjectA != null && ObjectA.PropertyA !=null && ObjectA.PropertyA.PropertyB != null)
{
    // safely pull off the value
    int value = objectA.PropertyA.PropertyB.PropertyC;
}

Sería bueno hacer algo más como esto (pseudocódigo).

int value = ObjectA.PropertyA.PropertyB ? ObjectA.PropertyA.PropertyB : defaultVal;

Posiblemente colapsó aún más con un operador de fusión nula.

EDITAR Originalmente dije que mi segundo ejemplo era como js, ​​pero lo cambié a psuedo-code ya que se señaló correctamente que no funcionaría en js.

En C # 6 puede usar el operador condicional nulo . Entonces la prueba original será:

int? value = objectA?.PropertyA?.PropertyB?.PropertyC;

Método de extensión corto:

public static TResult IfNotNull<TInput, TResult>(this TInput o, Func<TInput, TResult> evaluator)
  where TResult : class where TInput : class
{
  if (o == null) return null;
  return evaluator(o);
}

Utilizando

PropertyC value = ObjectA.IfNotNull(x => x.PropertyA).IfNotNull(x => x.PropertyB).IfNotNull(x => x.PropertyC);

Puede encontrar este método de extensión simple y mucho más en http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

EDITAR:

Después de usarlo por un momento, creo que el nombre correcto para este método debería ser IfNotNull () en lugar del original With ().

¿Puedes agregar un método a tu clase? Si no es así, ¿ha pensado en utilizar métodos de extensión? Puede crear un método de extensión para su tipo de objeto llamado GetPropC().

Ejemplo:

public static class MyExtensions
{
    public static int GetPropC(this MyObjectType obj, int defaltValue)
    {
        if (obj != null && obj.PropertyA != null & obj.PropertyA.PropertyB != null)
            return obj.PropertyA.PropertyB.PropertyC;
        return defaltValue;
    }
}

Uso:

int val = ObjectA.GetPropC(0); // will return PropC value, or 0 (defaltValue)

Por cierto, esto supone que está utilizando .NET 3 o superior.

La forma en que lo estás haciendo es correcta.

Usted podría utilizar un truco como el descrito aquí , usando expresiones LINQ:

int value = ObjectA.NullSafeEval(x => x.PropertyA.PropertyB.PropertyC, 0);

Pero es mucho más lento que verificar manualmente cada propiedad ...

Refactorizar para observar la Ley de Deméter

Actualización 2014: C # 6 tiene un nuevo operador ?.llamado 'navegación segura' o 'propagación nula'

parent?.child

Lea http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx para obtener más detalles

Esta ha sido durante mucho tiempo una solicitud muy popular https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Obviamente, está buscando la mónada anulable :

string result = new A().PropertyB.PropertyC.Value;

se convierte en

string result = from a in new A()
                from b in a.PropertyB
                from c in b.PropertyC
                select c.Value;

Esto devuelve null, si alguna de las propiedades que aceptan valores NULL es nula; de lo contrario, el valor de Value.

class A { public B PropertyB { get; set; } }
class B { public C PropertyC { get; set; } }
class C { public string Value { get; set; } }

Métodos de extensión LINQ:

public static class NullableExtensions
{
    public static TResult SelectMany<TOuter, TInner, TResult>(
        this TOuter source,
        Func<TOuter, TInner> innerSelector,
        Func<TOuter, TInner, TResult> resultSelector)
        where TOuter : class
        where TInner : class
        where TResult : class
    {
        if (source == null) return null;
        TInner inner = innerSelector(source);
        if (inner == null) return null;
        return resultSelector(source, inner);
    }
}

Suponiendo que tiene valores vacíos de tipos, un enfoque sería este:

var x = (((objectA ?? A.Empty).PropertyOfB ?? B.Empty).PropertyOfC ?? C.Empty).PropertyOfString;

Soy un gran fan de C #, pero una cosa muy buena en el nuevo Java (¿1.7?) Es el.? operador:

 var x = objectA.?PropertyOfB.?PropertyOfC.?PropertyOfString;

Este código es "la menor cantidad de código", pero no la mejor práctica:

try
{
    return ObjectA.PropertyA.PropertyB.PropertyC;
}
catch(NullReferenceException)
{
     return null;
}

Cuando necesito encadenar llamadas como esa, confío en un método auxiliar que creé, TryGet ():

    public static U TryGet<T, U>(this T obj, Func<T, U> func)
    {
        return obj.TryGet(func, default(U));
    }

    public static U TryGet<T, U>(this T obj, Func<T, U> func, U whenNull)
    {
        return obj == null ? whenNull : func(obj);
    }

En su caso, lo usaría así:

    int value = ObjectA
        .TryGet(p => p.PropertyA)
        .TryGet(p => p.PropertyB)
        .TryGet(p => p.PropertyC, defaultVal);

Vi algo en el nuevo C # 6.0, esto es usando '?' en lugar de comprobar

por ejemplo en lugar de usar

if (Person != null && Person.Contact!=null && Person.Contact.Address!= null && Person.Contact.Address.City != null)
{ 
  var city = person.contact.address.city;
}

simplemente usa

var city = person?.contact?.address?.city;

Espero que haya ayudado a alguien.

ACTUALIZAR:

Podrías hacer esto ahora

 var city = (Person != null)? 
           ((Person.Contact!=null)? 
              ((Person.Contact.Address!= null)?
                      ((Person.Contact.Address.City!=null)? 
                                 Person.Contact.Address.City : null )
                       :null)
               :null)
            : null;

Podrías hacer esto:

class ObjectAType
{
    public int PropertyC
    {
        get
        {
            if (PropertyA == null)
                return 0;
            if (PropertyA.PropertyB == null)
                return 0;
            return PropertyA.PropertyB.PropertyC;
        }
    }
}



if (ObjectA != null)
{
    int value = ObjectA.PropertyC;
    ...
}

O incluso mejor podría ser esto:

private static int GetPropertyC(ObjectAType objectA)
{
    if (objectA == null)
        return 0;
    if (objectA.PropertyA == null)
        return 0;
    if (objectA.PropertyA.PropertyB == null)
        return 0;
    return objectA.PropertyA.PropertyB.PropertyC;
}


int value = GetPropertyC(ObjectA);

puedes usar la siguiente extensión y creo que es realmente buena:

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<TF, TR>(TF t, Func<TF, TR> f)
    where TF : class
{
    return t != null ? f(t) : default(TR);
}

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<T1, T2, TR>(T1 p1, Func<T1, T2> p2, Func<T2, TR> p3)
    where T1 : class
    where T2 : class
{
    return Get(Get(p1, p2), p3);
}

/// <summary>
/// Simplifies null checking
/// </summary>
public static TR Get<T1, T2, T3, TR>(T1 p1, Func<T1, T2> p2, Func<T2, T3> p3, Func<T3, TR> p4)
    where T1 : class
    where T2 : class
    where T3 : class
{
    return Get(Get(Get(p1, p2), p3), p4);
}

Y se usa así:

int value = Nulify.Get(objectA, x=>x.PropertyA, x=>x.PropertyB, x=>x.PropertyC);

Escribiría su propio método en el tipo de PropertyA (o un método de extensión si no es su tipo) usando un patrón similar al tipo Nullable.

class PropertyAType
{
   public PropertyBType PropertyB {get; set; }

   public PropertyBType GetPropertyBOrDefault()
   {
       return PropertyB != null ? PropertyB : defaultValue;
   }
}

Acabo de tropezar con esta publicación.

Hace algún tiempo hice una sugerencia en Visual Studio Connect acerca de agregar un nuevo ???operador.

http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/4104392-add-as-an-recursive-null-reference-check-opera

Esto requeriría algo de trabajo por parte del equipo del marco, pero no es necesario modificar el lenguaje, solo hacer algo de magia del compilador. La idea era que el compilador debería cambiar este código (sintaxis no permitida atm)

string product_name = Order.OrderDetails[0].Product.Name ??? "no product defined";

en este código

Func<string> _get_default = () => "no product defined"; 
string product_name = Order == null 
    ? _get_default.Invoke() 
    : Order.OrderDetails[0] == null 
        ? _get_default.Invoke() 
        : Order.OrderDetails[0].Product == null 
            ? _get_default.Invoke() 
            : Order.OrderDetails[0].Product.Name ?? _get_default.Invoke()

Para comprobar nulo, esto podría verse así

bool isNull = (Order.OrderDetails[0].Product ??? null) == null;

Escribí un método que acepta un valor predeterminado, así es como se usa:

var teacher = new Teacher();
return teacher.GetProperty(t => t.Name);
return teacher.GetProperty(t => t.Name, "Default name");

Aquí está el código:

public static class Helper
{
    /// <summary>
    /// Gets a property if the object is not null.
    /// var teacher = new Teacher();
    /// return teacher.GetProperty(t => t.Name);
    /// return teacher.GetProperty(t => t.Name, "Default name");
    /// </summary>
    public static TSecond GetProperty<TFirst, TSecond>(this TFirst item1,
        Func<TFirst, TSecond> getItem2, TSecond defaultValue = default(TSecond))
    {
        if (item1 == null)
        {
            return defaultValue;
        }

        return getItem2(item1);
    }
}

No es posible.
ObjectA.PropertyA.PropertyBfallará si ObjectAes nulo debido a la eliminación de referencias nulas, lo cual es un error.

if(ObjectA != null && ObjectA.PropertyA... funciona debido a un cortocircuito, es decir ObjectA.PropertyA, nunca se comprobará si ObjectAes así null.

La primera forma que propongas es la mejor y la más clara con intención. En todo caso, podría intentar rediseñar sin tener que depender de tantos nulos.

Este enfoque es bastante sencillo una vez que superas el lambda gobbly-gook:

public static TProperty GetPropertyOrDefault<TObject, TProperty>(this TObject model, Func<TObject, TProperty> valueFunc)  
                                                        where TObject : class
    {
        try
        {
            return valueFunc.Invoke(model);
        }
        catch (NullReferenceException nex)
        {
            return default(TProperty);
        }
    }

Con un uso que podría verse así:

ObjectA objectA = null;

Assert.AreEqual(0,objectA.GetPropertyOrDefault(prop=>prop.ObjectB.ObjectB.ObjectC.ID));

Assert.IsNull(objectA.GetPropertyOrDefault(prop => prop.ObjectB));

var result = nullableproperty ?? defaultvalue;

El ??(operador de fusión nula) significa que si el primer argumento es null, devuelve el segundo en su lugar.