C# элегантный способ проверить, является ли свойство свойства нулевым.

Question

В C# скажите, что вы хотите вывести значение из PropertyC в этом примере, а ObjectA, PropertyA и PropertyB могут быть пустыми.

ObjectA.PropertyA.PropertyB.PropertyC

Как я могу получить PropertyC безопасно с наименьшим количеством кода?

Прямо сейчас я хотел бы проверить:

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

Было бы неплохо сделать что-то больше похоже на это (псевдо-код).

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

Возможно, еще больше рухнуло с помощью оператора с нулевым коалесцированием.

EDIT Первоначально я сказал, что мой второй пример был похож на js, но я изменил его на psuedo-code, так как он правильно указал, что он не будет работать в js.

Answer 1

В C# 6 вы можете использовать Null Условный Оператор.Таким образом, оригинальный тест будет:

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

Answer 2

Я бы написал свой собственный метод в виде PropertyA (или метода расширения, если это не ваш тип), используя аналогичный шаблон для типа Nullable.

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

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

Answer 3

То, как вы это делаете, является правильным.

Вы могли использовать трюк как описанный here, используя выражения Linq:

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

Но это гораздо медленнее, чем вручную проверять каждое свойство ...

Answer 4

Это не представляется возможным. ObjectA.PropertyA.PropertyB не удастся, если ObjectA имеет значение null из-за нулевой разыменования, что является ошибкой.

если (Objecta! = NULL & & ObjectA.PropertyA ... работает из-за короткого замыкания, т.е. ObjectA.PropertyA никогда не будет проверяться, если Objecta является недействительным.

Первый способ вы предлагаете это лучший и наиболее ясно с намерением Если все, что вы могли бы попытаться редизайн без необходимости полагаться на столько нулям

Answer 5

Этот код «наименьшее количество кода», но не лучшая практика:..

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

Answer 6

C вы добавляете метод в свой класс? Если нет, подумали ли вы об использовании методов расширения? Вы можете создать метод расширения для вашего типа объекта, который называется GetPropC().

Пример:

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

Использование:

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

Кстати, это предполагает, что вы используете .NET 3 или выше.

Answer 7

Вы можете сделать это:

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

Или еще лучше может быть это:

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

Answer 8

Refactor наблюдать Law of Demeter

Answer 9

Если у вас есть пустые значения типов один подход был бы это:

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

Я большой поклонник C#, но очень хорошая вещь в новой Java (1.7?) - это.? Оператор:

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

Answer 10

Вы, очевидно, ищешь Nullable Монады:

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

становится

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

Это возвращает null, если какие-либо из обнуляемых свойств равно нуль; в противном случае - значение Value.

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

---

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

Answer 11

Проверить this blog post наружу. Я думаю, что это очень элегантный метод для цепочки нулевых проверок. Есть много подобных реализаций этого, но мне это нравится, потому что он перестает оценивать, как только нуль обнаруживается в цепочке.

Весь исходный код находится на github.

Answer 12

Этот подход является довольно прямо вперед, как только вы получите через лямбда gobbly-Гук:

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

С обычаем, который может выглядеть как:

ObjectA objectA = null; 

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

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

Answer 13

var result = nullableproperty ?? defaultvalue; 

The ?? оператор означает, что первый аргумент равен нулю, вместо этого верните второй.

Answer 14

Когда мне нужно цепи вызовов, как это, я полагаюсь на вспомогательный метод, я создал, 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); 
    } 

В вашем случае, вы будете использовать его так:

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

Answer 15

Просто наткнулся на этот пост.

Некоторое время назад я сделал предложение по Visual Studio Connect о добавлении нового оператора ???.

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

Это потребует некоторой работы с рамочной команды, но не нужно, чтобы изменить язык, а просто сделать некоторые компилятор магии. Идея заключалась в том, что компилятор должен изменить этот код (синтаксис не разрешено атм)

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

в этот код

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

Для проверки нулевой это может выглядеть

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

Answer 16

вы можете использовать следующее расширение, и я думаю, что это действительно хорошо:

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

И он используется так:

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

Answer 17

Короткий метод расширения:

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

Использование

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

Этот простой метод расширения и многое другое вы можете найти на http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/

EDIT:

После использования этого момента я думаю, что правильное имя для этого метода должно быть IfNotNull() вместо оригинала With().

Answer 18

Null распространение планируется в C# vNext, питание от Рослин

---

Не ответ, но больше обновления. Похоже, что UserVoice загнал это, наряду с плотом других новых вещей, так как Рослин и, по-видимому спланированная дополнение:

https://roslyn.codeplex.com/discussions/540883

Answer 19

Update 2014: C# 6 появился новый оператор ?. различных называется «безопасной навигация»или„нулевой распространяющаяся“

parent?.child 

Читать http://blogs.msdn.com/b/jerrynixon/archive/2014/02/26/at-last-c-is-getting-sometimes-called-the-safe-navigation-operator.aspx подробности

Это уже давно очень популярный запрос https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d

Answer 20

Я написал метод, который принимает значение по умолчанию, вот как его использовать:

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

Вот код:

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

Answer 21

я увидел что-то в новом C# 6.0, это с помощью «?» вместо проверки

, например, вместо того, чтобы использовать

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

вы просто использовать

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

Я надеюсь, что это помогло кому-то.

---

UPDATE:

Вы могли бы сделать, как это сейчас

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