Wywołanie metody, jeśli nie ma wartości null w C #

Czy da się jakoś skrócić to stwierdzenie?

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

ponieważ często to piszę i robi się to dość irytujące. Jedyne, co przychodzi mi do głowy, to zaimplementowanie wzorca Null Object , ale nie jest to to, co mogę zrobić za każdym razem i na pewno nie jest to rozwiązanie do skrócenia składni.

I podobny problem z wydarzeniami, gdzie

public event Func<string> MyEvent;

a następnie wywołaj

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

Począwszy od C # 6, możesz po prostu użyć:

MyEvent?.Invoke();

lub:

obj?.SomeMethod();

?.Jest operatorem null rozmnożeniowego, oraz powoduje .Invoke()się zwarcie przy operandzienull . Dostęp do operandu jest możliwy tylko raz, więc nie ma ryzyka wystąpienia problemu „zmiany wartości między sprawdzaniem a wywołaniem”.

===

Przed C # 6 nie: nie ma magii zerowej, z jednym wyjątkiem; metody rozszerzające - na przykład:

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

teraz to jest ważne:

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

W przypadku wydarzeń ma to tę zaletę, że usuwa również warunek wyścigu, tj. Nie potrzebujesz zmiennej tymczasowej. Więc normalnie potrzebujesz:

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

ale z:

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

możemy użyć po prostu:

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

Co szukasz jest Null warunkowe (nie „koalescencyjny”) operator: ?.. Jest dostępny od C # 6.

Twój przykład to obj?.SomeMethod();. Jeśli obiekt ma wartość null, nic się nie dzieje. Gdy metoda ma argumenty, np obj?.SomeMethod(new Foo(), GetBar());. Argumenty nie są obliczane, jeśli objjest zerowe, co ma znaczenie, jeśli ocena argumentów miałaby skutki uboczne.

Łańcuch jest możliwy: myObject?.Items?[0]?.DoSomething()

Szybka metoda rozszerzenia:

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

przykład:

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

lub alternatywnie:

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

przykład:

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

Zdarzenia można zainicjować z pustym domyślnym delegatem, który nigdy nie jest usuwany:

public event EventHandler MyEvent = delegate { };

Nie jest konieczne sprawdzanie wartości zerowej.

[ Aktualizacja , dzięki Bevan za wskazanie tego]

Pamiętaj jednak o możliwym wpływie na wydajność. Szybki mikro-test porównawczy, który przeprowadziłem, wskazuje, że obsługa zdarzenia bez subskrybentów jest 2-3 razy wolniejsza przy użyciu wzorca „domyślny delegat”. (Na moim dwurdzeniowym laptopie 2,5 GHz oznacza to 279 ms: 785 ms na zebranie 50 milionów niezasubskrybowanych wydarzeń). W przypadku punktów aktywnych aplikacji może to być kwestia do rozważenia.

Tak, w C # 6.0 - https://msdn.microsoft.com/en-us/magazine/dn802602.aspx .

object?.SomeMethod()

Ten artykuł Iana Griffithsa podaje dwa różne rozwiązania problemu, które, jak stwierdza, są zgrabnymi sztuczkami, których nie powinieneś używać.

Metoda przedłużania ceracji, taka jak ta sugerowana, nie rozwiązuje problemów związanych z warunkami wyścigu, ale raczej je ukrywa.

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

Jak stwierdzono, ten kod jest eleganckim odpowiednikiem rozwiązania z tymczasową zmienną, ale ...

Problem z obojgiem polega na tym, że możliwe jest wywołanie abonenta wydarzenia PO wypisaniu się z wydarzenia . Jest to możliwe, ponieważ anulowanie subskrypcji może nastąpić po skopiowaniu wystąpienia delegata do zmiennej tymczasowej (lub przekazaniu jako parametru w powyższej metodzie), ale przed wywołaniem delegata.

Generalnie zachowanie kodu klienta jest w takim przypadku nieprzewidywalne: stan komponentu nie mógł już pozwolić na obsługę powiadomienia o zdarzeniu. Możliwe jest napisanie kodu klienta w taki sposób, aby go obsłużyć, ale spowodowałoby to niepotrzebną odpowiedzialność po stronie klienta.

Jedynym znanym sposobem zapewnienia bezpieczeństwa wątków jest użycie instrukcji lock dla nadawcy zdarzenia. Gwarantuje to, że wszystkie subskrypcje \ unsubscriptions \ invocation są serializowane.

Aby być dokładniejszym, blokada powinna być zastosowana do tego samego obiektu synchronizacji, który jest używany w metodach dostępu do zdarzenia add \ remove, czyli domyślnie „this”.

Zgadzam się z odpowiedzią Kenny'ego Eliassona. Idź z metodami rozszerzającymi. Oto krótki przegląd metod rozszerzających i wymaganej metody IfNotNull.

Metody rozszerzające (metoda IfNotNull)

Może nie lepiej, ale moim zdaniem bardziej czytelne jest stworzenie metody rozszerzającej

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

Jest do tego mało znany operator null w języku C #, ??. Może być pomocny:

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