C# eleganter Weg, um zu überprüfen, ob eine Eigenschaft die Eigenschaft den Wert null

Kurze Extension Methode:

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

Mit

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

Diese einfache Erweiterung Methode und vieles mehr finden Sie auf http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

EDIT:

Nachdem es ihn für den moment denke ich, der richtige name für diese Methode sollte IfNotNull() statt original Mit().

InformationsquelleAutor der Antwort Krzysztof Morcinek

Die Art und Weise Sie es tun, richtig ist.

Du könnte verwenden einen trick, wie beschrieben,hiermithilfe von Linq-Ausdrücke :

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

Aber es ist viel langsamer, manuell überprüfen jede Eigenschaft...

InformationsquelleAutor der Antwort Thomas Levesque

Du bist offensichtlich auf der Suche für die Nullable-Monade:

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

wird

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

Zurück null wenn die nullable-Eigenschaften null ist; andernfalls wird der Wert von Value.

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

LINQ extension Methoden:

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

InformationsquelleAutor der Antwort dtb

Dieser code ist "the least amount of code", aber nicht die beste Praxis:

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

InformationsquelleAutor der Antwort Boris Modylevsky

Überprüfen in diesem blog-post aus. Ich denke, es ist eine sehr elegante Methode für verkettete null prüft. Es gibt viele ähnliche Implementierungen, aber diese mag ich, weil es Stoppt die Auswertung, sobald eine null gefunden wird, die in der Kette.

Allem der source-code ist auf github.

InformationsquelleAutor der Antwort codeConcussion

Sah ich etwas in der neuen C# 6.0,
dies ist durch die Verwendung von '?' anstelle der überprüfung

anstatt z.B.

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

verwenden Sie einfach

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

Ich hoffe, es half jemand.

UPDATE:

Könnten Sie tun, wie dieser jetzt

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

InformationsquelleAutor der Antwort iYazee6

Ist es nicht möglich. ObjectA.PropertyA.PropertyB fehl, wenn ObjectA null ist, wegen null-Dereferenzierung, das ist ein Fehler.

if(ObjectA != null && ObjectA.PropertyA ... funktioniert durch Kurzschluss, dh ObjectA.PropertyA wird nie überprüft werden, ob ObjectA null ist.

Die erste Möglichkeit, die Sie vorschlagen, ist die beste und die meisten klar mit Vorsatz. Wenn alles, was Sie konnte umgestalten, um die zimmerreserviereung, ohne das Vertrauen auf die so viele null-Werte.

InformationsquelleAutor der Antwort DanDan

können Sie die folgenden Erweiterung und ich denke, es ist wirklich gut:

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

Und es wird wie folgt verwendet:

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

InformationsquelleAutor der Antwort Tony

Ich würde schreiben Sie Ihre eigene Methode in der Art der PropertyA (oder eine Erweiterung Methode, wenn es nicht Ihre Art) mit dem ähnlichen Muster auf die Nullable-Typ.

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

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

InformationsquelleAutor der Antwort Steve Danner

Dieser Ansatz ist ziemlich straight-forward-sobald man über die 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);
        }
    }

Nutzung das Aussehen könnte:

ObjectA objectA = null;

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

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

InformationsquelleAutor der Antwort BlackjacketMack