Modo elegante in C # per verificare se la proprietà di una proprietà è nulla

In C #, si supponga di voler estrarre un valore da PropertyC in questo esempio e ObjectA, PropertyA e PropertyB possono essere tutti null.

ObjectA.PropertyA.PropertyB.PropertyC

Come posso ottenere PropertyC in modo sicuro con la minor quantità di codice?

In questo momento vorrei controllare:

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

Sarebbe bello fare qualcosa di più simile a questo (pseudo-codice).

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

Forse anche ulteriormente collassato con un operatore di coalescenza nullo.

EDIT Inizialmente ho detto che il mio secondo esempio era come js, ma l'ho cambiato in codice psuedo poiché è stato correttamente sottolineato che non avrebbe funzionato in js.

In C # 6 è possibile utilizzare l' operatore condizionale null . Quindi il test originale sarà:

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

Metodo di estensione breve:

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

Utilizzando

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

Questo semplice metodo di estensione e molto altro puoi trovare su http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

MODIFICARE:

Dopo averlo usato per un momento, penso che il nome corretto per questo metodo dovrebbe essere IfNotNull () invece dell'originale With ().

Puoi aggiungere un metodo alla tua classe? In caso contrario, hai pensato di utilizzare metodi di estensione? È possibile creare un metodo di estensione per il tipo di oggetto chiamato GetPropC().

Esempio:

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

Utilizzo:

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

A proposito, questo presuppone che tu stia utilizzando .NET 3 o versioni successive.

Il modo in cui lo stai facendo è corretto.

Si potrebbe usare un trucco come quello descritto qui , utilizzando espressioni Linq:

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

Ma è molto più lento che controllare manualmente ogni proprietà ...

Rifattore per osservare la Legge di Demetra

Aggiornamento 2014: C # 6 ha un nuovo operatore ?.chiamato "navigazione sicura" o "propagazione null"

parent?.child

Leggi http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx per i dettagli

Questa è stata a lungo una richiesta estremamente popolare https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Stai ovviamente cercando la Monade nullable :

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

diventa

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

Restituisce null, se una qualsiasi delle proprietà nullable è null; in caso contrario, il valore di Value.

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

Metodi di estensione 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);
    }
}

Supponendo che tu abbia valori vuoti di tipi, un approccio sarebbe questo:

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

Sono un grande fan di C # ma una cosa molto carina nel nuovo Java (1.7?) È il.? operatore:

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

Questo codice è "la quantità minima di codice", ma non la best practice:

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

Quando ho bisogno di concatenare chiamate in questo modo, mi affido a un metodo di supporto che ho creato, 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);
    }

Nel tuo caso, lo useresti così:

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

Ho visto qualcosa nel nuovo C # 6.0, utilizzando "?" invece di controllare

per esempio invece di usare

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

usi semplicemente

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

Spero abbia aiutato qualcuno.

AGGIORNARE:

Potresti fare così adesso

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

Potresti farlo:

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 ancora meglio potrebbe essere questo:

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

puoi usare la seguente estensione e penso che sia davvero buono:

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

Ed è usato in questo modo:

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

Vorrei scrivere il tuo metodo nel tipo di PropertyA (o un metodo di estensione se non è il tuo tipo) usando il modello simile al tipo Nullable.

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

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

Sono appena inciampato in questo post.

Qualche tempo fa ho suggerito a Visual Studio Connect di aggiungere un nuovo ???operatore.

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

Ciò richiederebbe un po 'di lavoro da parte del team del framework, ma non è necessario modificare il linguaggio, ma solo fare un po' di magia del compilatore. L'idea era che il compilatore dovesse modificare questo codice (sintassi non consentita atm)

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

in questo codice

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()

Per il controllo nullo questo potrebbe apparire come

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

Ho scritto un metodo che accetta un valore predefinito, ecco come usarlo:

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

Ecco il codice:

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

Non è possibile.
ObjectA.PropertyA.PropertyBfallirà se ObjectAè nullo a causa della dereferenziazione nullo, che è un errore.

if(ObjectA != null && ObjectA.PropertyA... funziona a causa di cortocircuito, ovvero ObjectA.PropertyAnon verrà mai verificato se lo ObjectAè null.

Il primo modo in cui proponi è il migliore e il più chiaro con l'intento. Semmai potresti provare a riprogettare senza dover fare affidamento su così tanti null.

Questo approccio è abbastanza semplice una volta superato il 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 utilizzo che potrebbe assomigliare a:

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;

L ' ??(operatore di coalescenza null) significa che se il primo argomento è null, restituisci invece il secondo.