C # елегантний спосіб перевірити, чи є властивість властивості нульовою

У 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-код, оскільки було правильно вказано, що він не буде працювати в js.

У C # 6 ви можете використовувати нульовий умовний оператор . Тож оригінальним тестом буде:

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

Метод короткого розширення:

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/

Редагувати:

Після його використання на даний момент, я думаю, що власною назвою цього методу має бути IfNotNull () замість оригінального With ().

Чи можете ви додати метод до свого класу? Якщо ні, ви думали про використання методів розширення? Ви можете створити метод розширення для типу об'єкта, який називається 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 або новішу версію.

Те, як ви це робите, є правильним.

Ви можете використовувати фокус, як описаний тут , використовуючи вирази Linq:

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

Але набагато повільніше, що вручну перевіряти кожну власність ...

Рефактор дотримується закону Деметра

Оновлення 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

Ви, очевидно, шукаєте монаду, яка може бути припустима :

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, якщо будь-яке з властивостей, що допускають нуль, має значення 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);
    }
}

Якщо припустимо, що у вас є порожні значення типів, одним підходом було б таке:

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

Я великий фанат C #, але дуже приємною річчю в новій Java (1.7?) Є. оператор:

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

Цей код - "найменша кількість коду", але не найкраща практика:

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

Коли мені потрібно зациклювати дзвінки таким чином, я покладаюся на допоміжний метод, який я створив, 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);

Я бачив щось у новому 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;

Сподіваюся, це комусь допомогло.

ОНОВЛЕННЯ:

Ви могли б зробити це зараз

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

Ви можете зробити це:

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

Ви можете використовувати наступне розширення, і я думаю, що це дійсно добре:

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

Я записав би свій власний метод у тип PropertyA (або метод розширення, якщо це не ваш тип), використовуючи аналогічний зразок типу Nullable.

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

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

Щойно натрапив на цей пост.

Деякий час тому я зробив пропозицію на Visual Studio Connect щодо додавання нового ???оператора.

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

Це зажадає певної роботи від фреймворкової команди, але не потрібно змінювати мову, а просто робити магію компілятора. Ідея полягала в тому, що компілятор повинен змінити цей код (синтаксис atm не дозволений)

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;

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

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

Це неможливо.
ObjectA.PropertyA.PropertyBвийде з ладу, якщо ObjectAє null через нульову перенаправлення, що є помилкою.

if(ObjectA != null && ObjectA.PropertyA... працює через коротке замикання, тобто ObjectA.PropertyAніколи не буде перевірено, якщо ObjectAє null.

Перший спосіб, який ви пропонуєте, є найкращим і найбільш зрозумілим з намірами. У будь-якому випадку ви можете спробувати переробити дизайн, не маючи покластися на стільки нулів.

Цей підхід досить прямолінійний, як тільки ви переходите через лямбда-гобла:

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

var result = nullableproperty ?? defaultvalue;

Оператор ??(null-coalescing) означає, якщо перший аргумент є null, поверніть замість нього другий.