C # elegante Methode, um zu überprüfen, ob die Eigenschaft einer Eigenschaft null ist

Angenommen, Sie möchten in C # einen Wert von PropertyC in diesem Beispiel abrufen, und ObjectA, PropertyA und PropertyB können alle null sein.

ObjectA.PropertyA.PropertyB.PropertyC

Wie kann ich PropertyC mit der geringsten Menge an Code sicher erhalten?

Im Moment würde ich überprüfen:

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

Es wäre schön, so etwas mehr zu machen (Pseudocode).

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

Möglicherweise ist er mit einem Null-Koaleszenz-Operator noch weiter zusammengebrochen.

BEARBEITEN Ursprünglich sagte ich, mein zweites Beispiel sei wie js, aber ich habe es in Pseudo-Code geändert, da richtig darauf hingewiesen wurde, dass es in js nicht funktionieren würde.

In C # 6 können Sie den Null-Bedingungsoperator verwenden . Der ursprüngliche Test lautet also:

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

Kurze Verlängerungsmethode:

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

Verwenden von

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

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

BEARBEITEN:

Nachdem ich es für einen Moment benutzt habe, denke ich, dass der richtige Name für diese Methode IfNotNull () anstelle von original With () sein sollte.

Können Sie Ihrer Klasse eine Methode hinzufügen? Wenn nicht, haben Sie über die Verwendung von Erweiterungsmethoden nachgedacht? Sie können eine Erweiterungsmethode für Ihren Objekttyp mit dem Namen erstellen GetPropC().

Beispiel:

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

Verwendung:

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

Dies setzt übrigens voraus, dass Sie .NET 3 oder höher verwenden.

Die Art und Weise, wie Sie es tun, ist richtig.

Sie können einen Trick wie den hier beschriebenen mit Linq-Ausdrücken verwenden:

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

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

Refactor zur Einhaltung des Demeter-Gesetzes

Update 2014: C # 6 hat einen neuen Operator ?.namens "Sichere Navigation" oder "Null-Propagierung".

parent?.child

Weitere Informationen finden Sie unter http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx

Dies ist seit langem eine äußerst beliebte Anfrage: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Sie suchen offensichtlich nach der Nullable Monad :

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;

Dies gibt zurück null, wenn eine der nullbaren 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-Erweiterungsmethoden:

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

Angenommen, Sie haben leere Werte vom Typ. Ein Ansatz wäre folgender:

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

Ich bin ein großer Fan von C #, aber eine sehr schöne Sache in neuem Java (1.7?) Ist das.? Operator:

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

Dieser Code ist "die geringste Menge an Code", aber nicht die beste Vorgehensweise:

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

Wenn ich solche Aufrufe verketten muss, verlasse ich mich auf eine von mir erstellte Hilfsmethode, 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);
    }

In Ihrem Fall würden Sie es so verwenden:

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

Ich habe etwas in der neuen C # 6.0 gesehen, dies ist mit '?' anstatt zu überprüfen

zum Beispiel anstatt zu verwenden

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

Sie verwenden einfach

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

Ich hoffe es hat jemandem geholfen.

AKTUALISIEREN:

Das könntest du jetzt so machen

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

Sie könnten dies tun:

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

Oder noch besser könnte dies sein:

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

Sie können die folgende Erweiterung verwenden und ich finde es 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 so verwendet:

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

Ich würde Ihre eigene Methode im Typ PropertyA (oder eine Erweiterungsmethode, wenn es nicht Ihr Typ ist) unter Verwendung des ähnlichen Musters wie der Typ Nullable schreiben.

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

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

Bin gerade über diesen Beitrag gestolpert.

Vor einiger Zeit habe ich in Visual Studio Connect einen Vorschlag zum Hinzufügen eines neuen ???Operators gemacht.

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

Dies würde einige Arbeit vom Framework-Team erfordern, aber nicht die Sprache ändern, sondern nur etwas Compiler-Magie ausführen. Die Idee war, dass der Compiler diesen Code ändern sollte (Syntax nicht erlaubt atm)

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

in diesen Code

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

Bei einer Nullprüfung könnte dies so aussehen

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

Ich habe eine Methode geschrieben, die einen Standardwert akzeptiert. So verwenden Sie ihn:

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

Hier ist der Code:

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

Es ist nicht möglich.
ObjectA.PropertyA.PropertyBschlägt fehl, wenn ObjectAnull aufgrund einer Null-Dereferenzierung vorliegt, was ein Fehler ist.

if(ObjectA != null && ObjectA.PropertyA... funktioniert aufgrund eines Kurzschlusses, dh ObjectA.PropertyAwird nie überprüft, ob dies der Fall ObjectAist null.

Der erste Weg, den Sie vorschlagen, ist der beste und klarste mit Absicht. Wenn überhaupt, könnten Sie versuchen, neu zu gestalten, ohne sich auf so viele Nullen verlassen zu müssen.

Dieser Ansatz ist ziemlich unkompliziert, sobald Sie den Lambda-Gobbly-Gook überwunden haben:

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

Bei Verwendung könnte das so aussehen:

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;

Der ??(Null-Koaleszenz-Operator) bedeutet, wenn das erste Argument lautet null, geben Sie stattdessen das zweite zurück.