Event C#: từ khóa event, EventHandler, đăng ký và kích hoạt

Event (sự kiện) cho phép một lớp thông báo rằng có chuyện vừa xảy ra mà không cần biết ai đang lắng nghe. Các đối tượng khác đăng ký bằng +=, và khi lớp kích hoạt event, phương thức của mọi subscriber đều chạy.

using System;

class OrderPlacedEventArgs : EventArgs
{
    public string OrderId { get; }
    public decimal Total { get; }

    public OrderPlacedEventArgs(string orderId, decimal total)
    {
        OrderId = orderId;
        Total = total;
    }
}

class Shop
{
    public event EventHandler<OrderPlacedEventArgs> OrderPlaced;

    public void PlaceOrder(string id, decimal total)
    {
        Console.WriteLine($"Order {id} saved");
        OrderPlaced?.Invoke(this, new OrderPlacedEventArgs(id, total));
    }
}

class Program
{
    static void SendReceipt(object sender, OrderPlacedEventArgs e)
    {
        Console.WriteLine($"  receipt emailed for {e.OrderId}");
    }

    static void Main()
    {
        var shop = new Shop();
        shop.OrderPlaced += SendReceipt;
        shop.OrderPlaced += (sender, e) =>
        {
            if (e.Total > 100m) Console.WriteLine($"  free gift added to {e.OrderId}");
        };

        shop.PlaceOrder("A-17", 45m);
        shop.PlaceOrder("A-18", 180m);
    }
}

Đầu ra:

Order A-17 saved
  receipt emailed for A-17
Order A-18 saved
  receipt emailed for A-18
  free gift added to A-18

Shop không hề biết đến hóa đơn hay quà tặng. Nó kích hoạt OrderPlaced, và bất cứ thứ gì đã đăng ký sẽ phản ứng. Thêm một phản ứng mới (điểm thưởng, phân tích dữ liệu) nghĩa là thêm một subscriber, không phải sửa PlaceOrder.

Khai báo event

Khai báo event là một thành viên có kiểu delegate kèm từ khóa event:

public event EventHandler<OrderPlacedEventArgs> OrderPlaced;

Kiểu delegate quyết định chữ ký của handler. Code .NET gần như luôn dùng một trong hai kiểu có sẵn, và theo đúng quy ước giúp event của bạn quen thuộc với mọi lập trình viên .NET khác:

• EventHandler: void (object sender, EventArgs e), cho event không mang dữ liệu. Kích hoạt bằng EventArgs.Empty.
• EventHandler<TEventArgs>: void (object sender, TEventArgs e), trong đó TEventArgs là lớp của bạn chứa dữ liệu.

Các quy ước đi kèm:

• sender là đối tượng đã kích hoạt event, thường là this.
• Lớp dữ liệu được đặt tên {Something}EventArgs, kế thừa từ EventArgs (không bắt buộc từ .NET 4.5, nhưng vẫn là thói quen chung) và cung cấp các thuộc tính chỉ đọc.
• Event được đặt tên theo việc đã xảy ra: OrderPlaced, Closed, PriceChanged. Tên dạng ...ing (Closing) dùng cho event được kích hoạt trước hành động, thường kèm cách để hủy hành động đó.
• Trong các lớp dùng để kế thừa, việc kích hoạt đi qua một phương thức protected virtual void OnOrderPlaced(OrderPlacedEventArgs e), để lớp dẫn xuất có thể can thiệp.

Đăng ký và hủy đăng ký

+= thêm một handler và -= gỡ nó ra. Handler có thể là một phương thức hoặc một lambda. Muốn gỡ lambda về sau, hãy giữ nó trong một biến, vì viết lại đúng lambda đó sẽ tạo ra một delegate khác mà -= không tìm thấy:

using System;

class Thermostat
{
    public event EventHandler<int> TemperatureChanged;

    public void Set(int celsius)
    {
        Console.WriteLine($"set to {celsius}");
        TemperatureChanged?.Invoke(this, celsius);
    }
}

class Program
{
    static void Main()
    {
        var thermostat = new Thermostat();

        EventHandler<int> display = (s, t) => Console.WriteLine($"  display shows {t} C");
        EventHandler<int> alarm = (s, t) =>
        {
            if (t > 30) Console.WriteLine("  alarm: too hot");
        };

        thermostat.TemperatureChanged += display;
        thermostat.TemperatureChanged += alarm;
        thermostat.Set(32);

        thermostat.TemperatureChanged -= alarm;
        thermostat.Set(35);

        thermostat.TemperatureChanged -= (s, t) => Console.WriteLine("never subscribed");
        thermostat.Set(20);
    }
}

Đầu ra:

set to 32
  display shows 32 C
  alarm: too hot
set to 35
  display shows 35 C
set to 20
  display shows 20 C

Gỡ một handler chưa từng được thêm không phải là lỗi; việc này không làm gì cả. EventHandler<int> cho thấy trên .NET hiện đại, đối số kiểu không bắt buộc phải kế thừa từ EventArgs, dù một lớp riêng vẫn chừa chỗ để thêm trường về sau mà không làm hỏng subscriber.

Handler chạy đồng bộ, theo thứ tự đăng ký, trên luồng đã kích hoạt event. Nếu một handler ném ngoại lệ, các handler còn lại không chạy và ngoại lệ lan lên code đã kích hoạt event.

Kích hoạt event an toàn

Một event chưa có subscriber nào chứa null. Gọi trực tiếp sẽ ném NullReferenceException, nên hãy kích hoạt bằng toán tử null-conditional:

OrderPlaced?.Invoke(this, args);

Trước C# 6, cách làm là sao chép trường vào một biến cục bộ, kiểm tra rồi gọi bản sao. Bản sao quan trọng trong code đa luồng: kiểm tra OrderPlaced != null rồi gọi OrderPlaced(...) sẽ đọc trường hai lần, và một luồng khác có thể gỡ handler cuối cùng ở giữa. ?. chỉ đọc một lần, nên vừa ngắn gọn vừa đúng.

Vì sao dùng event mà không dùng trường delegate public

Không có từ khóa event, một trường delegate public vẫn dùng để đăng ký được, nhưng nó trao toàn quyền cho mọi subscriber:

using System;

class Button
{
    public Action Clicked;                   // no 'event' keyword
    public void Click() => Clicked?.Invoke();
}

class Program
{
    static void Main()
    {
        var button = new Button();
        button.Clicked += () => Console.WriteLine("save document");
        button.Clicked += () => Console.WriteLine("play click sound");

        button.Clicked = () => Console.WriteLine("analytics ping");   // '=' instead of '+='
        button.Click();

        button.Clicked();                    // any code can fire it, too
    }
}

Đầu ra:

analytics ping
analytics ping

Chỉ một dấu = gõ nhầm thay cho += đã âm thầm gỡ bỏ hai handler trước đó, và code bên ngoài có thể kích hoạt "click" mà không cần cú click nào. Đánh dấu trường là event khiến cả hai dòng đều thành lỗi biên dịch:

error CS0070: The event 'Button.Clicked' can only appear on the left hand side of += or -= (except when used from within the type 'Button')

Bên trong Button, event vẫn hoạt động như một trường delegate bình thường, nên lớp có thể gọi nó và kiểm tra null.

Rò rỉ bộ nhớ do quên hủy đăng ký

Khi bạn đăng ký, event lưu một delegate, và delegate đó giữ tham chiếu đến đối tượng subscriber. Chừng nào publisher còn sống và handler còn gắn vào, subscriber không thể được bộ thu gom rác (garbage collector) dọn đi, và nó vẫn tiếp tục nhận event dù bạn đã dùng xong:

using System;

class PriceFeed
{
    public event EventHandler<decimal> PriceChanged;

    public void Publish(decimal price) => PriceChanged?.Invoke(this, price);

    public int SubscriberCount =>
        PriceChanged == null ? 0 : PriceChanged.GetInvocationList().Length;
}

class PriceWidget : IDisposable
{
    private readonly PriceFeed feed;
    private readonly string name;

    public PriceWidget(PriceFeed feed, string name)
    {
        this.feed = feed;
        this.name = name;
        feed.PriceChanged += OnPriceChanged;
    }

    private void OnPriceChanged(object sender, decimal price) =>
        Console.WriteLine($"  {name} shows {price}");

    public void Dispose() => feed.PriceChanged -= OnPriceChanged;
}

class Program
{
    static void Main()
    {
        var feed = new PriceFeed();                 // lives for the whole app

        var leaky = new PriceWidget(feed, "closed widget");   // never disposed
        leaky = null;

        using (var widget = new PriceWidget(feed, "open widget"))
        {
            feed.Publish(101.5m);
        }                                            // Dispose unsubscribes

        Console.WriteLine($"subscribers left: {feed.SubscriberCount}");
        feed.Publish(99.0m);
    }
}

Đầu ra:

  closed widget shows 101.5
  open widget shows 101.5
subscribers left: 1
  closed widget shows 99.0

Gán leaky bằng null không thay đổi gì với feed: danh sách handler của nó vẫn tham chiếu đến widget đó, nên widget "đã đóng" vẫn tiếp tục cập nhật và nằm lại trong bộ nhớ. Widget trong khối using đã hủy đăng ký trong Dispose và ngừng nhận event. Đây là một trong những kiểu rò rỉ bộ nhớ phổ biến nhất trong code .NET cho desktop và máy chủ, đặc biệt với event static và các service dùng cho toàn ứng dụng, vốn sống đến khi tiến trình kết thúc.

Quy tắc: ai đăng ký event trên một đối tượng sống lâu hơn mình thì phải hủy đăng ký, thường là trong Dispose (xem câu lệnh using). Khi publisher và subscriber có cùng vòng đời, chẳng hạn một form và các nút của chính nó, thì không cần hủy đăng ký.

Accessor add và remove tự định nghĩa

Một event có thể tự định nghĩa việc += và -= làm gì, giống get và set của thuộc tính. Cách này hiếm gặp, nhưng là cách các framework lưu handler trong một từ điển dùng chung hoặc chuyển tiếp chúng sang một đối tượng khác:

private EventHandler closed;

public event EventHandler Closed
{
    add    { Console.WriteLine("subscriber added");   closed += value; }
    remove { Console.WriteLine("subscriber removed"); closed -= value; }
}

Với accessor tự định nghĩa, lớp kích hoạt event thông qua trường lưu trữ (closed?.Invoke(this, EventArgs.Empty)), vì bản thân event không còn nơi lưu trữ.