C # elegancki sposób sprawdzania, czy właściwość właściwości jest null

W C # powiedz, że chcesz pobrać wartość z PropertyC w tym przykładzie, a ObjectA, PropertyA i PropertyB mogą mieć wartość null.

ObjectA.PropertyA.PropertyB.PropertyC

Jak mogę bezpiecznie uzyskać PropertyC przy najmniejszej ilości kodu?

Teraz sprawdziłbym:

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

Byłoby miło zrobić coś więcej takiego (pseudokod).

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

Prawdopodobnie jeszcze bardziej upadł z operatorem koalescencji zerowej.

EDYCJA Pierwotnie powiedziałem, że mój drugi przykład był podobny do js, ​​ale zmieniłem go na psuedo-code, ponieważ zostało prawidłowo wskazane, że nie będzie działać w js.

W C # 6 możesz użyć operatora warunkowego o wartości Null . Więc oryginalny test będzie wyglądał następująco:

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

Metoda krótkiego przedłużenia:

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

Za pomocą

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

Ta prosta metoda rozszerzenia i wiele więcej można znaleźć na http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

EDYTOWAĆ:

Po chwilowym użyciu, myślę, że właściwą nazwą tej metody powinno być IfNotNull () zamiast oryginalnego With ().

Czy możesz dodać metodę do swojej klasy? Jeśli nie, czy myślałeś o użyciu metod rozszerzających? Możesz utworzyć metodę rozszerzenia dla swojego typu obiektu o nazwie GetPropC().

Przykład:

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

Stosowanie:

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

Przy okazji zakłada się, że używasz platformy .NET 3 lub nowszej.

Sposób, w jaki to robisz, jest poprawny.

Państwo mogli korzystać trick jak opisany tutaj , używając wyrażeń Linq:

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

Jednak ręczne sprawdzanie każdej właściwości jest znacznie wolniejsze ...

Refaktoryzuj, aby przestrzegać prawa Demeter

Aktualizacja 2014: C # 6 ma nowego operatora o ?.nazwie „bezpieczna nawigacja” lub „propagacja zerowa”

parent?.child

Przeczytaj http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx, aby uzyskać szczegółowe informacje

To od dawna bardzo popularne żądanie https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Oczywiście szukasz monady Nullable :

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

staje się

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

Zwraca to null, jeśli którakolwiek z właściwości dopuszczających wartość null ma wartość null; w przeciwnym razie wartość Value.

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

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

Zakładając, że masz puste wartości typów, jedno podejście byłoby takie:

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

Jestem wielkim fanem C #, ale bardzo fajną rzeczą w nowej Javie (1.7?) Jest.? operator:

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

Ten kod jest „najmniejszą ilością kodu”, ale nie jest najlepszym rozwiązaniem:

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

Kiedy muszę łączyć wywołania w ten sposób, polegam na utworzonej przeze mnie metodzie pomocniczej 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);
    }

W twoim przypadku użyłbyś go tak:

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

Widziałem coś w nowym C # 6.0, to jest za pomocą '?' zamiast sprawdzać

na przykład zamiast używać

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

po prostu używasz

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

Mam nadzieję, że komuś pomogło.

AKTUALIZACJA:

Możesz to teraz zrobić

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

Możesz to zrobić:

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

A może nawet lepiej:

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

możesz użyć następującego rozszerzenia i myślę, że jest naprawdę dobre:

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

I jest używany w ten sposób:

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

Napisałbym własną metodę w typie PropertyA (lub metodę rozszerzenia, jeśli nie jest to twój typ), używając podobnego wzorca do typu Nullable.

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

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

Właśnie natknąłem się na ten post.

Jakiś czas temu w Visual Studio Connect zasugerowałem dodanie nowego ???operatora.

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

Wymagałoby to trochę pracy zespołu ds. Frameworka, ale nie trzeba zmieniać języka, ale po prostu zrobić trochę magii kompilatora. Pomysł był taki, że kompilator powinien zmienić ten kod (składnia nie jest dozwolona w atm)

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

do tego kodu

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

Dla sprawdzenia zerowego może to wyglądać

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

Napisałem metodę, która akceptuje wartość domyślną, oto jak jej używać:

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

Oto kod:

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

To niemożliwe.
ObjectA.PropertyA.PropertyBzakończy się niepowodzeniem, jeśli ObjectAma wartość null z powodu wyłuskiwania odwołań o wartości zerowej, co jest błędem.

if(ObjectA != null && ObjectA.PropertyA... działa z powodu zwarcia, tzn. ObjectA.PropertyAnigdy nie będzie sprawdzane, czy ObjectAjest null.

Pierwsza propozycja jest najlepsza i najbardziej przejrzysta z zamiarem. Jeśli cokolwiek, możesz spróbować przeprojektować bez konieczności polegania na tak wielu zerach.

To podejście jest dość proste, gdy przejdziesz przez 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);
        }
    }

Przy użyciu, które może wyglądać następująco:

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;

W ??(null koalescencji operatorów) oznacza, że jeśli pierwszy argument jest null, należy zwrócić drugi zamian.