Вызов метода, если не null в C #

Можно ли как-то сократить это утверждение?

if (obj != null)
    obj.SomeMethod();

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

И аналогичная проблема с событиями, где

public event Func<string> MyEvent;

а затем вызвать

if (MyEvent != null)
    MyEvent.Invoke();

Начиная с C # 6, вы можете просто использовать:

MyEvent?.Invoke();

или:

obj?.SomeMethod();

Это ?.оператор с нулевым распространением и вызовет .Invoke()короткое замыкание, когда операнд null. Доступ к операнду осуществляется только один раз, поэтому нет риска возникновения проблемы «изменение значения между проверкой и вызовом».

===

До C # 6 нет: не существовало нулевого безопасного волшебства, за одним исключением; методы расширения - например:

public static void SafeInvoke(this Action action) {
    if(action != null) action();
}

теперь это действительно:

Action act = null;
act.SafeInvoke(); // does nothing
act = delegate {Console.WriteLine("hi");}
act.SafeInvoke(); // writes "hi"

В случае событий это имеет то преимущество, что также удаляет условие гонки, то есть вам не нужна временная переменная. Обычно вам понадобятся:

var handler = SomeEvent;
if(handler != null) handler(this, EventArgs.Empty);

но с:

public static void SafeInvoke(this EventHandler handler, object sender) {
    if(handler != null) handler(sender, EventArgs.Empty);
}

мы можем просто использовать:

SomeEvent.SafeInvoke(this); // no race condition, no null risk

Что вы ищете является Null Условный (не «сливаясь») Оператор: ?.. Он доступен с C # 6.

Ваш пример был бы obj?.SomeMethod();. Если obj имеет значение null, ничего не происходит. Когда метод имеет аргументы, например, obj?.SomeMethod(new Foo(), GetBar());аргументы не оцениваются, если objимеет значение null, что имеет значение, если оценка аргументов будет иметь побочные эффекты.

И возможна цепочка: myObject?.Items?[0]?.DoSomething()

Метод быстрого расширения:

    public static void IfNotNull<T>(this T obj, Action<T> action, Action actionIfNull = null) where T : class {
        if(obj != null) {
            action(obj);
        } else if ( actionIfNull != null ) {
            actionIfNull();
        }
    }

пример:

  string str = null;
  str.IfNotNull(s => Console.Write(s.Length));
  str.IfNotNull(s => Console.Write(s.Length), () => Console.Write("null"));

или альтернативно:

    public static TR IfNotNull<T, TR>(this T obj, Func<T, TR> func, Func<TR> ifNull = null) where T : class {
        return obj != null ? func(obj) : (ifNull != null ? ifNull() : default(TR));
    }

пример:

    string str = null;
    Console.Write(str.IfNotNull(s => s.Length.ToString());
    Console.Write(str.IfNotNull(s => s.Length.ToString(), () =>  "null"));

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

public event EventHandler MyEvent = delegate { };

Нет необходимости в нулевой проверке.

[ Обновление , спасибо Бевану за указание на это]

Однако имейте в виду возможное влияние на производительность. Быстрый микротест, который я провел, показывает, что обработка события без подписчиков происходит в 2-3 раза медленнее при использовании шаблона «делегат по умолчанию». (На моем двухъядерном ноутбуке с частотой 2,5 ГГц это означает 279 мс: 785 мс для сбора 50 миллионов событий без подписки.) Это может быть проблемой для горячих точек приложений.

Да, в C # 6.0 - https://msdn.microsoft.com/en-us/magazine/dn802602.aspx .

object?.SomeMethod()

В этой статье Яна Гриффитса представлены два разных решения проблемы, которые, по его мнению, представляют собой изящные уловки, которые вам не следует использовать.

Предлагаемый метод расширения Cerating на самом деле не решает проблемы с условиями гонки, а скорее скрывает их.

public static void SafeInvoke(this EventHandler handler, object sender)
{
    if (handler != null) handler(sender, EventArgs.Empty);
}

Как указано, этот код является элегантным эквивалентом решения с временной переменной, но ...

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

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

Единственный известный способ обеспечить безопасность потока - использовать инструкцию блокировки для отправителя события. Это гарантирует, что все подписки \ отписки \ вызовы будут сериализованы.

Чтобы быть более точным, блокировку следует применить к тому же объекту синхронизации, который используется в методах доступа к событию add \ remove, который по умолчанию является this.

Я согласен с ответом Кенни Элиассона. Используйте методы расширения. Вот краткий обзор методов расширения и необходимого вам метода IfNotNull.

Методы расширения (метод IfNotNull)

Может быть, не лучше, но, на мой взгляд, более читабельным будет создание метода расширения

public static bool IsNull(this object obj) {
 return obj == null;
}

Для этого в C # есть малоизвестный нулевой оператор ??. Может быть полезно:

http://weblogs.asp.net/scottgu/archive/2007/09/20/the-new-c-null-coalescing-operator-and-using-it-with-linq.aspx