Có nhược điểm của việc thêm một đại biểu trống ẩn danh vào khai báo sự kiện không?

Tôi đã thấy một vài đề cập đến thành ngữ này (kể cả trên SO ):

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

Ưu điểm là rõ ràng - nó tránh được sự cần thiết phải kiểm tra null trước khi nâng cao sự kiện.

Tuy nhiên, tôi muốn hiểu liệu có bất kỳ nhược điểm nào không. Ví dụ, nó có phải là thứ đang được sử dụng rộng rãi và đủ minh bạch để không gây đau đầu cho việc bảo trì không? Có bất kỳ hiệu suất đáng kể nào của cuộc gọi thuê bao sự kiện trống không?

Nhược điểm duy nhất là một hình phạt hiệu suất rất nhẹ khi bạn đang gọi thêm đại biểu trống. Ngoài ra không có hình phạt bảo trì hoặc nhược điểm khác.

Thay vì gây ra chi phí hiệu suất, tại sao không sử dụng một phương pháp mở rộng để giảm bớt cả hai vấn đề:

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

Sau khi được xác định, bạn không bao giờ phải kiểm tra lại sự kiện rỗng khác:

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

Đối với các hệ thống sử dụng nhiều sự kiện và quan trọng về hiệu suất , bạn chắc chắn sẽ muốn ít nhất cân nhắc việc không làm điều này. Chi phí để nâng cao một sự kiện với một đại biểu trống gần gấp đôi chi phí để nâng cao sự kiện đó với một kiểm tra rỗng trước.

Dưới đây là một số con số chạy điểm chuẩn trên máy của tôi:

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

Và đây là mã tôi đã sử dụng để lấy những số liệu này:

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

Nếu bạn đang làm điều đó một / lot /, bạn có thể muốn có một đại biểu trống duy nhất, tĩnh / được chia sẻ mà bạn sử dụng lại, chỉ đơn giản là để giảm khối lượng các thể hiện đại biểu. Lưu ý rằng trình biên dịch vẫn lưu trữ đại biểu này cho mỗi sự kiện (trong trường tĩnh), vì vậy nó chỉ là một trường hợp đại biểu cho mỗi định nghĩa sự kiện, vì vậy nó không phải là một khoản tiết kiệm lớn - nhưng có thể đáng giá.

Tất nhiên, trường per-instance trong mỗi lớp sẽ vẫn có cùng một không gian.

I E

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

Ngoài ra, nó có vẻ ổn.

Không có hình phạt thực hiện có ý nghĩa nào để nói về, ngoại trừ, có thể, đối với một số tình huống khắc nghiệt.

Tuy nhiên, lưu ý rằng thủ thuật này trở nên ít liên quan hơn trong C # 6.0, bởi vì ngôn ngữ này cung cấp một cú pháp thay thế để gọi các đại biểu có thể là null:

delegateThatCouldBeNull?.Invoke(this, value);

Ở trên, toán tử điều kiện null ?.kết hợp kiểm tra null với một lệnh gọi có điều kiện.

Tôi hiểu rằng đại biểu rỗng là luồng an toàn, trong khi kiểm tra rỗng thì không.

Tôi sẽ nói rằng đó là một cấu trúc hơi nguy hiểm, bởi vì nó cám dỗ bạn làm những điều như:

MyEvent(this, EventArgs.Empty);

Nếu máy khách ném một ngoại lệ, máy chủ sẽ đi theo nó.

Vì vậy, sau đó, có thể bạn làm:

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

Tuy nhiên, nếu bạn có nhiều người đăng ký và một người đăng ký có ngoại lệ, điều gì sẽ xảy ra với những người đăng ký khác?

Để đạt được điều đó, tôi đã sử dụng một số phương thức trợ giúp tĩnh thực hiện việc kiểm tra null và nuốt bất kỳ ngoại lệ nào từ phía người đăng ký (đây là từ idesign).

// 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
        { }
    }
}

Thay vì cách tiếp cận "đại biểu rỗng", người ta có thể xác định một phương thức mở rộng đơn giản để đóng gói phương pháp thông thường để kiểm tra trình xử lý sự kiện so với null. Nó được mô tả ở đây và ở đây .

Cho đến nay, một điều bị bỏ sót khi là câu trả lời cho câu hỏi này: Thật nguy hiểm nếu tránh kiểm tra giá trị null .

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

Vấn đề là: Bạn không bao giờ biết ai sẽ sử dụng mã của bạn theo cách nào. Bạn không bao giờ biết, nếu trong một số năm trong quá trình sửa lỗi mã của bạn, sự kiện / trình xử lý được đặt thành null.

Luôn luôn viết séc nếu.

Hy vọng điều đó sẽ giúp;)

ps: Cảm ơn vì đã tính toán hiệu suất.

pps: Đã chỉnh sửa nó từ một trường hợp sự kiện thành và ví dụ gọi lại. Cảm ơn bạn đã phản hồi ... Tôi đã "viết mã" ví dụ về Visual Studio và điều chỉnh ví dụ mà tôi có trong đầu thành một sự kiện. Xin lỗi vì sự nhầm lẫn.

ppps: Không biết nó có còn phù hợp với luồng không ... nhưng tôi nghĩ đó là một nguyên tắc quan trọng. Vui lòng kiểm tra một chuỗi khác của stackflow