Event C#: Keyword event, EventHandler, Subscribe, dan Raise

Event memungkinkan sebuah class mengumumkan bahwa sesuatu terjadi tanpa tahu siapa yang mendengarkan. Object lain melakukan subscribe dengan +=, dan saat class itu memunculkan event-nya, method milik setiap subscriber dijalankan.

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

Output:

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 tidak tahu bahwa struk atau hadiah itu ada. Class ini memunculkan OrderPlaced, dan apa pun yang sudah subscribe akan bereaksi. Menambahkan reaksi baru (poin loyalitas, analitik) berarti menambahkan subscriber, bukan mengubah PlaceOrder.

Mendeklarasikan event

Deklarasi event adalah member bertipe delegate dengan keyword event:

public event EventHandler<OrderPlacedEventArgs> OrderPlaced;

Tipe delegate-nya menentukan signature handler. Kode .NET hampir selalu memakai salah satu dari dua tipe bawaan, dan mengikuti konvensi ini membuat event-mu terasa familier bagi setiap developer .NET lain:

• EventHandler: void (object sender, EventArgs e), untuk event yang tidak membawa data. Munculkan dengan EventArgs.Empty.
• EventHandler<TEventArgs>: void (object sender, TEventArgs e), dengan TEventArgs adalah class milikmu yang membawa datanya.

Konvensi di sekitarnya:

• sender adalah object yang memunculkan event, biasanya this.
• Class datanya diberi nama {Something}EventArgs, diturunkan dari EventArgs (opsional sejak .NET 4.5, tetapi masih lazim), dan mengekspos property read-only.
• Event diberi nama sesuai apa yang terjadi: OrderPlaced, Closed, PriceChanged. Nama berakhiran ...ing (Closing) dipakai untuk event yang dimunculkan sebelum aksinya, sering kali dengan cara untuk membatalkannya.
• Di class yang dimaksudkan untuk diwarisi, event dimunculkan lewat method protected virtual void OnOrderPlaced(OrderPlacedEventArgs e), supaya class turunan bisa ikut campur.

Subscribe dan unsubscribe

+= menambahkan handler dan -= menghapusnya. Handler bisa berupa method atau lambda. Untuk menghapus lambda nanti, simpan lambda itu di variabel, karena menulis lambda yang sama lagi menghasilkan delegate berbeda yang tidak akan ditemukan oleh -=:

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

Output:

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

Menghapus handler yang tidak pernah ditambahkan bukan error; hal itu tidak berbuat apa-apa. EventHandler<int> menunjukkan bahwa argumen tipenya tidak harus diturunkan dari EventArgs di .NET modern, meskipun class khusus memberi ruang untuk menambahkan field nanti tanpa merusak subscriber.

Handler berjalan secara sinkron, sesuai urutan subscribe, di thread yang memunculkan event. Kalau satu handler melempar exception, handler sisanya tidak dijalankan dan exception-nya diteruskan ke kode yang memunculkan event.

Memunculkan event dengan aman

Event tanpa subscriber berisi null. Memanggilnya secara langsung akan melempar NullReferenceException, jadi munculkan dengan operator null-conditional:

OrderPlaced?.Invoke(this, args);

Sebelum C# 6, polanya adalah menyalin field ke variabel lokal, mengeceknya, lalu memanggil salinannya. Salinan itu penting di kode multithread: mengecek OrderPlaced != null lalu memanggil OrderPlaced(...) membaca field-nya dua kali, dan thread lain bisa menghapus handler terakhir di antaranya. ?. membacanya sekali, jadi lebih singkat sekaligus benar.

Kenapa event, bukan field delegate public

Tanpa keyword event, field delegate public tetap bisa dipakai untuk subscribe, tetapi memberi setiap subscriber kendali penuh:

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

Output:

analytics ping
analytics ping

Satu = yang diketik alih-alih += diam-diam menghapus dua handler sebelumnya, dan kode dari luar bisa memunculkan "klik" tanpa ada klik sama sekali. Menandai field-nya dengan event membuat kedua baris itu menjadi error compile:

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

Di dalam Button, event itu tetap berperilaku seperti field delegate biasa, jadi class itu bisa memanggilnya dan mengecek apakah nilainya null.

Leak karena lupa unsubscribe

Saat kamu subscribe, event menyimpan sebuah delegate, dan delegate itu menyimpan reference ke object subscriber. Selama publisher masih hidup dan handler-nya masih terpasang, subscriber tidak bisa dibersihkan garbage collector, dan terus menerima event setelah kamu selesai memakainya:

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

Output:

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

Mengisi leaky dengan null tidak berpengaruh apa-apa bagi feed: daftar handler-nya masih mereferensikan widget itu, jadi widget yang "ditutup" terus diperbarui dan tetap ada di memori. Widget di dalam blok using melakukan unsubscribe di Dispose dan berhenti menerima event. Ini salah satu memory leak paling umum di kode desktop dan server .NET, terutama dengan event static dan service yang dipakai di seluruh aplikasi, yang hidup sampai proses berakhir.

Aturannya: siapa pun yang subscribe ke event milik object yang umurnya lebih panjang darinya harus unsubscribe, biasanya di Dispose (lihat pernyataan using). Saat publisher dan subscriber punya umur yang sama, seperti sebuah form dan tombol-tombolnya sendiri, unsubscribe tidak diperlukan.

Accessor add dan remove buatan sendiri

Sebuah event bisa menentukan apa yang dilakukan += dan -=, seperti get dan set pada property. Hal ini jarang dipakai, tetapi begitulah cara framework menyimpan handler di dictionary bersama atau meneruskannya ke object lain:

private EventHandler closed;

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

Dengan accessor buatan sendiri, class memunculkan event lewat backing field-nya (closed?.Invoke(this, EventArgs.Empty)), karena event itu sendiri tidak lagi punya penyimpanan.