C # 'da boş değilse yöntem çağrısı

Bu ifadeyi bir şekilde kısaltmak mümkün mü?

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

çünkü bunu çok yazıyorum ve oldukça sinir bozucu oluyor. Aklıma gelen tek şey, Boş Nesne kalıbını uygulamaktır , ancak her seferinde yapabileceğim şey bu değil ve kesinlikle sözdizimini kısaltmak için bir çözüm değil.

Ve olaylarla ilgili benzer bir sorun, nerede

public event Func<string> MyEvent;

ve sonra çağır

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

C # 6'dan itibaren şunları kullanabilirsiniz:

MyEvent?.Invoke();

veya:

obj?.SomeMethod();

?.Boş yayılan operatörüdür ve neden olacaktır .Invoke()işlenen olduğunda kısa devre edilecek null. İşlenene yalnızca bir kez erişilir, bu nedenle "kontrol ve çağırma arasında değer değişikliği" sorunu riski yoktur.

===

C # 6'dan önce, hayır: Bir istisna dışında sıfır güvenli sihir yoktur; uzantı yöntemleri - örneğin:

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

şimdi bu geçerlidir:

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

Olaylar söz konusu olduğunda, bunun aynı zamanda yarış koşulunu ortadan kaldırma avantajı vardır, yani geçici bir değişkene ihtiyacınız yoktur. Normalde ihtiyacınız olacak:

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

fakat:

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

basitçe kullanabiliriz:

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

Ne aradığınız olan Null-Koşullu operatör ( "kaynaştırma" değil): ?.. C # 6'dan itibaren mevcuttur.

Örneğiniz olacaktır obj?.SomeMethod();. Obj null ise hiçbir şey olmaz. Metodun argümanları olduğunda, örneğin obj?.SomeMethod(new Foo(), GetBar());argümanların objboş olup olmadığı değerlendirilmez, argümanların değerlendirilmesinin yan etkileri olacaksa önemlidir.

Ve zincirleme mümkündür: myObject?.Items?[0]?.DoSomething()

Hızlı bir uzatma yöntemi:

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

misal:

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

Veya alternatif olarak:

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

misal:

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

Olaylar, hiçbir zaman kaldırılmayan boş bir varsayılan delege ile başlatılabilir:

public event EventHandler MyEvent = delegate { };

Boş kontrol gerekli değildir.

[ Güncelleme , bunu işaret ettiği için Bevan'a teşekkürler]

Yine de olası performans etkisinin farkında olun. Yaptığım hızlı bir mikro kıyaslama, "varsayılan delege" modelini kullanırken abonesi olmayan bir olayı işlemenin 2-3 kat daha yavaş olduğunu gösteriyor. (Çift çekirdekli 2.5GHz dizüstü bilgisayarımda bu, abone olunmayan 50 milyon etkinliği artırmak için 279ms: 785ms anlamına geliyor.). Uygulama sıcak noktaları için bu, dikkate alınması gereken bir sorun olabilir.

Evet, C # 6.0'da - https://msdn.microsoft.com/en-us/magazine/dn802602.aspx .

object?.SomeMethod()

Ian Griffiths'in bu makalesi, kullanmamanız gereken düzgün numaralar olduğu sonucuna vardığı soruna iki farklı çözüm sunuyor.

Önerildiği gibi sertifika uzatma yöntemi, yarış koşullarıyla ilgili sorunları gerçekten çözmez, aksine onları gizler.

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

Belirtildiği gibi bu kod, geçici değişkenli çözüme mükemmel bir eşdeğerdir, ancak ...

Her ikisindeki sorun , etkinliğin abonesinin etkinlikten çıktıktan SONRA çağrılabilmesidir . Bu mümkündür, çünkü abonelik iptali temsilci örneği temp değişkenine kopyalandıktan sonra (veya yukarıdaki yöntemde parametre olarak iletildikten sonra), ancak temsilci çağrılmadan önce gerçekleşebilir.

Genel olarak, böyle bir durumda istemci kodunun davranışı tahmin edilemez: bileşen durumu, olay bildirimini halihazırda işlemeye izin veremezdi. Müşteri kodunu işleyebilecek şekilde yazmak mümkündür, ancak müşteriye gereksiz sorumluluk yükler.

İş parçacığı güvenliğini sağlamanın bilinen tek yolu, olayı gönderen için kilit ifadesini kullanmaktır. Bu, tüm aboneliklerin \ abonelikten çıkma \ çağrıların serileştirilmesini sağlar.

Daha doğru olmak için kilit, varsayılan 'this' olan add \ remove olay erişimci yöntemlerinde kullanılan aynı senkronizasyon nesnesine uygulanmalıdır.

Kenny Eliasson'ın cevabına katılıyorum. Uzantı yöntemleriyle gidin. Burada uzatma yöntemlerine ve gerekli IfNotNull yönteminize kısa bir genel bakış yer almaktadır.

Uzantı Yöntemleri (IfNotNull yöntemi)

Belki daha iyi değil ama bence daha okunaklı bir uzatma yöntemi oluşturmaktır

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

Kullandığım bu genel uzantıyı yaptım.

public static class ObjectExtensions {
    public static void With<T>(this T value, Action<T> todo) {
        if (value != null) todo(value);
    }
}

O zaman aşağıdaki gibi kullanıyorum.

string myString = null;
myString.With((value) => Console.WriteLine(value)); // writes nothing
myString = "my value";
myString.With((value) => Console.WriteLine(value)); // Writes `my value`

Bunun için C # 'da az bilinen bir boş operatör var ??. Yardımcı olabilir:

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