Возможные ошибки при использовании этого сокращения (на основе метода расширения)

Лично, даже после всех ваших объяснений, я не могу вспомнить, как это, черт возьми, работает:

if ( obj1.NullCompare( obj2, (x,y) => x.Property == y.Property ) 

Это могло быть потому, что у меня нет опыта работы с C#; однако я мог прочитать и понять все остальное в вашем коде. Я предпочитаю сохранять независимость от языка кода (особенно для тривиальных вещей), чтобы завтра другой разработчик мог изменить его на совершенно новый язык без излишней информации о существующем языке.

Если вам нужно очень часто проверять, является ли ссылка на объект нулевой, возможно, вам следует использовать Шаблон пустого объекта. В этом шаблоне вместо использования null для случая, когда у вас нет объекта, вы реализуете новый класс с тем же интерфейсом, но с методами и свойствами, которые возвращают адекватные значения по умолчанию.

it does make the code a little easier to read, but at the cost of extending object. This would appear on everything,

Обратите внимание, что вы на самом деле ничего не расширяете (кроме теоретических).

propertyValue2 = myObject2.IfNotNull( x => x.IntProperty, 0);

сгенерирует IL-код точно так же, как если бы он был написан:

ExtentionClass::IfNotNull(myObject2,  x => x.IntProperty, 0);

К объектам не добавляются "накладные расходы", чтобы поддержать это.

Как

propertyValue1 = myObject.IfNotNull(o => o.ObjectProp.IfNotNull( p => p.StringProperty ) );

легче читать и писать, чем

if (myObject != null && myObject.ObjectProp != null)
    propertyValue1 = myObject.ObjectProp.StringProperty;

Джафар Хусейн опубликовал образец использования деревьев выражений для проверки нулевого значения в цепочке Макросы времени выполнения в C# 3.

Однако это, очевидно, влияет на производительность. Вот если бы у нас был способ сделать это во время компиляции.

Я просто должен сказать, что мне нравится этот хак!

Я не понимал, что методы расширения не предполагают нулевой проверки, но это имеет смысл. Как отметил Джеймс, сам вызов метода расширения не дороже обычного метода, однако, если вы делаете много этого, то имеет смысл следовать шаблону нулевого объекта, который предложил ljorquera. Или использовать нулевой объект и ?? все вместе.

class Class1
{
    public static readonly Class1 Empty = new Class1();
.
.
x = (obj1 ?? Class1.Empty).X;

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

propertyValue1 = Util.IfNotNull(myObject1, x => x.StringProperty );
propertyValue2 = Util.IfNotNull(myObject2, x => x.IntProperty, 0);

Файл "Утиль". решает, но является ИМО меньшим синтаксическим злом.

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

Хотя методы расширения обычно вызывают недоразумения при вызове из нулевых экземпляров, я думаю, что в этом случае целью является довольно просто.

string x = null;
int len = x.IfNotNull(y => y.Length, 0);

Я хотел бы быть уверен, что этот статический метод работает с типами значений, которые могут иметь значение null, например int?

Обновлено: компилятор говорит, что ни один из них не действителен:

    public void Test()
    {
        int? x = null;
        int a = x.IfNotNull(z => z.Value + 1, 3);
        int b = x.IfNotNull(z => z.Value + 1);
    }

Кроме этого, дерзайте.

Вот еще одно решение для связанных членов, включая методы расширения:

public static U PropagateNulls<T,U> ( this T obj
                                     ,Expression<Func<T,U>> expr) 
{  if (obj==null) return default(U);

   //uses a stack to reverse Member1(Member2(obj)) to obj.Member1.Member2 
   var members = new Stack<MemberInfo>();

   bool       searchingForMembers = true;
   Expression currentExpression   = expr.Body;

   while (searchingForMembers) switch (currentExpression.NodeType)
    { case ExpressionType.Parameter: searchingForMembers = false; break;

           case ExpressionType.MemberAccess:    
           { var ma= (MemberExpression) currentExpression;
             members.Push(ma.Member);
             currentExpression = ma.Expression;         
           } break;     

          case ExpressionType.Call:
          { var mc = (MethodCallExpression) currentExpression;
            members.Push(mc.Method);

           //only supports 1-arg static methods and 0-arg instance methods
           if (   (mc.Method.IsStatic && mc.Arguments.Count == 1) 
               || (mc.Arguments.Count == 0))
            { currentExpression = mc.Method.IsStatic ? mc.Arguments[0]
                                                     : mc.Object; 
              break;
            }

           throw new NotSupportedException(mc.Method+" is not supported");
         } 

        default: throw new NotSupportedException
                        (currentExpression.GetType()+" not supported");
  }

   object currValue = obj;
   while(members.Count > 0)
    { var m = members.Pop();

      switch(m.MemberType)
       { case MemberTypes.Field:
           currValue = ((FieldInfo) m).GetValue(currValue); 
           break;

         case MemberTypes.Method:
           var method = (MethodBase) m;
           currValue = method.IsStatic
                              ? method.Invoke(null,new[]{currValue})
                              : method.Invoke(currValue,null); 
           break;

         case MemberTypes.Property:
           var method = ((PropertyInfo) m).GetGetMethod(true);
                currValue = method.Invoke(currValue,null);
           break;

       }     

      if (currValue==null) return default(U);   
    }

   return (U) currValue;    
}

Затем вы можете сделать это, где any может быть null или none:

foo.PropagateNulls(x => x.ExtensionMethod().Property.Field.Method());

Мы независимо друг от друга придумали одно и то же имя и реализацию метода расширения: Метод расширения с нулевым распространением. Поэтому мы не думаем, что это сбивает с толку или злоупотребление методами расширения.

Я бы написал ваш "многоуровневый" пример с цепочкой следующим образом:

propertyValue1 = myObject.IfNotNull(o => o.ObjectProp).IfNotNull(p => p.StringProperty);

Есть теперь закрытая ошибка в Microsoft Connect, предлагающий "?" как новый оператор C#, который будет выполнять это нулевое распространение. Мадс Торгерсен (из группы разработчиков языка C#) кратко объяснил, почему они не будут его реализовывать.

Вот еще одно решение с использованием myObject.NullSafe (x => x.SomeProperty.NullSafe (x => x.SomeMethod)), объясненное на http://www.epitka.blogspot.com/

Не ответ на точный вопрос, но есть Нуль-условный операторв C# 6.0. Я могу поспорить, что использовать эту опцию в OP, начиная с C# 6.0, будет плохим выбором :)

Так что ваше выражение проще,

string propertyValue = myObject?.StringProperty;

Если myObject равен нулю, он возвращает ноль. Если свойство является типом значения, вы должны использовать эквивалентный тип, допускающий значение NULL, например,

int? propertyValue = myObject?.IntProperty;

В противном случае вы можете объединиться с оператором объединения с нулевым значением, чтобы получить значение по умолчанию в случае нулевого значения. Например,

int propertyValue = myObject?.IntProperty ?? 0;

?. - не единственный доступный синтаксис. Для проиндексированных свойств вы можете использовать ?[..]. Например,

string propertyValue = myObject?[index]; //returns null in case myObject is null

Одно удивительное поведение оператора ?. заключается в том, что он может разумно обходить последующие вызовы .Member, если объект оказывается нулевым. Один из таких примеров приведен по ссылке:

var result = value?.Substring(0, Math.Min(value.Length, length)).PadRight(length);

В этом случае result равен нулю, если value равен нулю, и выражение value.Length не приведет к NullReferenceException.