Olay bildirimine anonim boş bir delege eklemenin bir dezavantajı var mı?

Bu deyimden birkaç kez bahsettiğini gördüm ( SO dahil ):

// Deliberately empty subscriber
public event EventHandler AskQuestion = delegate {};

Tersi açıktır - olayı yükseltmeden önce boşluğu kontrol etme ihtiyacını ortadan kaldırır.

Bununla birlikte, herhangi bir dezavantaj olup olmadığını anlamak için sabırsızlanıyorum. Örneğin, yaygın kullanımda olan ve bakım baş ağrısına neden olmayacak kadar şeffaf olan bir şey mi? Boş etkinlik abonesi çağrısında kayda değer bir performans artışı var mı?

Tek dezavantajı, fazladan boş delege çağırdığınız için çok hafif bir performans cezasıdır. Bunun dışında bakım cezası veya başka bir dezavantaj yoktur.

Performans ek yükünü tetiklemek yerine, neden her iki sorunu da hafifletmek için bir uzatma yöntemi kullanmayalım :

public static void Raise(this EventHandler handler, object sender, EventArgs e)
{
    if(handler != null)
    {
        handler(sender, e);
    }
}

Bir kez tanımlandıktan sonra, bir daha asla boş olay kontrolü yapmanız gerekmez:

// Works, even for null events.
MyButtonClick.Raise(this, EventArgs.Empty);

Sistemler için olayların ağır faydalanmak ve performans açısından kritik olan , kesinlikle en az isteyeceksiniz düşünün yapmıyorum. Boş bir delege ile bir olayı oluşturmanın maliyeti, onu ilk önce boş bir denetimle yükseltmenin yaklaşık iki katıdır.

Makinemde kıyaslama yapan bazı rakamlar:

For 50000000 iterations . . .
No null check (empty delegate attached): 530ms
With null check (no delegates attached): 249ms
With null check (with delegate attached): 452ms

Ve işte bu rakamları almak için kullandığım kod:

using System;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Program
    {
        public event EventHandler<EventArgs> EventWithDelegate = delegate { };
        public event EventHandler<EventArgs> EventWithoutDelegate;

        static void Main(string[] args)
        {
            //warm up
            new Program().DoTimings(false);
            //do it for real
            new Program().DoTimings(true);

            Console.WriteLine("Done");
            Console.ReadKey();
        }

        private void DoTimings(bool output)
        {
            const int iterations = 50000000;

            if (output)
            {
                Console.WriteLine("For {0} iterations . . .", iterations);
            }

            //with anonymous delegate attached to avoid null checks
            var stopWatch = Stopwatch.StartNew();

            for (var i = 0; i < iterations; ++i)
            {
                RaiseWithAnonDelegate();
            }

            stopWatch.Stop();

            if (output)
            {
                Console.WriteLine("No null check (empty delegate attached): {0}ms", stopWatch.ElapsedMilliseconds);
            }


            //without any delegates attached (null check required)
            stopWatch = Stopwatch.StartNew();

            for (var i = 0; i < iterations; ++i)
            {
                RaiseWithoutAnonDelegate();
            }

            stopWatch.Stop();

            if (output)
            {
                Console.WriteLine("With null check (no delegates attached): {0}ms", stopWatch.ElapsedMilliseconds);
            }


            //attach delegate
            EventWithoutDelegate += delegate { };


            //with delegate attached (null check still performed)
            stopWatch = Stopwatch.StartNew();

            for (var i = 0; i < iterations; ++i)
            {
                RaiseWithoutAnonDelegate();
            }

            stopWatch.Stop();

            if (output)
            {
                Console.WriteLine("With null check (with delegate attached): {0}ms", stopWatch.ElapsedMilliseconds);
            }
        }

        private void RaiseWithAnonDelegate()
        {
            EventWithDelegate(this, EventArgs.Empty);
        }

        private void RaiseWithoutAnonDelegate()
        {
            var handler = EventWithoutDelegate;

            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }
}

Bunu bir / lot / yapıyorsanız, temsilci örneklerinin hacmini azaltmak için yeniden kullandığınız tek, statik / paylaşılan boş bir temsilciye sahip olmak isteyebilirsiniz. Derleyicinin bu temsilciyi her olay için (statik bir alanda) önbelleğe aldığına dikkat edin, bu nedenle olay tanımı başına yalnızca bir temsilci örneğidir, bu nedenle bu çok büyük bir tasarruf değildir - ama belki de zahmete değer.

Her sınıftaki örnek başına alan elbette aynı alanı kaplayacaktır.

yani

internal static class Foo
{
    internal static readonly EventHandler EmptyEvent = delegate { };
}
public class Bar
{
    public event EventHandler SomeEvent = Foo.EmptyEvent;
}

Bunun dışında iyi görünüyor.

Muhtemelen bazı aşırı durumlar haricinde konuşulacak anlamlı bir performans cezası yoktur.

Bununla birlikte, bu numara C # 6.0'da daha az alakalı hale gelir, çünkü dil, boş olabilecek delegeleri çağırmak için alternatif bir sözdizimi sağlar:

delegateThatCouldBeNull?.Invoke(this, value);

Yukarıda, boş koşullu operatör ?., boş denetimini koşullu bir çağrı ile birleştirir.

Anladığım kadarıyla boş delege iş parçacığı için güvenliyken, boş kontrol değil.

Bunun biraz tehlikeli bir yapı olduğunu söyleyebilirim, çünkü sizi şöyle bir şey yapmaya teşvik ediyor:

MyEvent(this, EventArgs.Empty);

İstemci bir istisna atarsa, sunucu onunla birlikte gider.

O zaman belki de yaparsın

try
{
  MyEvent(this, EventArgs.Empty);
}
catch
{
}

Ancak, birden fazla aboneniz varsa ve bir abone bir istisna atarsa, diğer abonelere ne olur?

Bu amaçla, null kontrolü yapan ve abone tarafından herhangi bir istisnayı yutan bazı statik yardımcı yöntemler kullanıyorum (bu, idesign'dan).

// Usage
EventHelper.Fire(MyEvent, this, EventArgs.Empty);


public static void Fire(EventHandler del, object sender, EventArgs e)
{
    UnsafeFire(del, sender, e);
}
private static void UnsafeFire(Delegate del, params object[] args)
{
    if (del == null)
    {
        return;
    }
    Delegate[] delegates = del.GetInvocationList();

    foreach (Delegate sink in delegates)
    {
        try
        {
            sink.DynamicInvoke(args);
        }
        catch
        { }
    }
}

"Boş delege" yaklaşımı yerine, olay işleyicisini boşa karşı kontrol etmenin geleneksel yöntemini kapsüllemek için basit bir genişletme yöntemi tanımlanabilir. Burada ve burada anlatılmaktadır .

Şimdiye kadar bu sorunun cevabı olarak bir şey gözden kaçtı: Boş değeri kontrol etmekten kaçınmak tehlikelidir .

public class X
{
    public delegate void MyDelegate();
    public MyDelegate MyFunnyCallback = delegate() { }

    public void DoSomething()
    {
        MyFunnyCallback();
    }
}


X x = new X();

x.MyFunnyCallback = delegate() { Console.WriteLine("Howdie"); }

x.DoSomething(); // works fine

// .. re-init x
x.MyFunnyCallback = null;

// .. continue
x.DoSomething(); // crashes with an exception

Mesele şu ki: Kodunuzu kimin hangi şekilde kullanacağını asla bilemezsiniz. Bazı yıllarda kodunuzun bir hata düzeltmesi sırasında olay / işleyicinin null olarak ayarlanıp ayarlanmadığını asla bilemezsiniz.

Her zaman, eğer kontrolünü yazın.

Umarım yardımcı olur ;)

ps: Performans hesaplaması için teşekkürler.

pps: Bir olay durumundan ve geri arama örneğinden düzenledi. Geri bildirim için teşekkürler ... Örneği Visual Studio olmadan "kodladım" ve aklımdaki örneği bir olaya ayarladım. Karışıklık için özür dilerim.

ppps: Hala iş parçacığına uyup uymadığını bilmiyorum ... ama önemli bir ilke olduğunu düşünüyorum. Lütfen başka bir yığın akışı dizisini de kontrol edin