Delegate trong C#: khai báo, gọi, multicast và callback

Delegate là một kiểu đại diện cho chữ ký phương thức. Biến có kiểu delegate giữ tham chiếu đến một phương thức có chữ ký đó, và gọi biến chính là gọi phương thức. Đây là cách C# coi hàm như giá trị: bạn có thể lưu chúng, truyền chúng cho phương thức khác và gọi chúng sau.

using System;

delegate decimal PriceRule(decimal price);

class Program
{
    static decimal HalfPrice(decimal p) => p / 2;
    static decimal MinusTen(decimal p) => p > 10m ? p - 10m : 0m;

    static void Main()
    {
        PriceRule rule = HalfPrice;
        Console.WriteLine(rule(80m));

        rule = MinusTen;
        Console.WriteLine(rule(80m));

        rule = p => p * 0.85m;
        Console.WriteLine(rule.Invoke(80m));
    }
}

Đầu ra:

40
70
68.00

delegate decimal PriceRule(decimal price); khai báo một kiểu mới, giống như class. Mọi phương thức nhận một decimal và trả về một decimal đều khớp với nó. Biến rule lần lượt trỏ đến ba phương thức khác nhau, và mỗi lần gọi chạy phương thức mà nó đang giữ.

Khai báo, tạo và gọi delegate

Khai báo kiểu delegate trông giống chữ ký phương thức có từ khóa delegate ở đầu. Nó thường nằm ở cấp namespace, cạnh các lớp, hoặc lồng bên trong một lớp.

Có bốn cách tạo một instance delegate:

PriceRule a = HalfPrice;                             // method group (most common)
PriceRule b = new PriceRule(HalfPrice);              // explicit constructor, same thing
PriceRule c = p => p - 5m;                            // lambda expression
PriceRule d = delegate (decimal p) { return p; };    // anonymous method (C# 2 syntax)

Và hai cách gọi nó, hoàn toàn giống nhau: rule(80m) và rule.Invoke(80m). Trình biên dịch kiểm tra chữ ký lúc gán, nên một phương thức không khớp là lỗi biên dịch chứ không phải bất ngờ lúc chạy.

Delegate cũng có thể trỏ đến phương thức của instance. Khi đó nó nhớ cả phương thức lẫn đối tượng sẽ gọi phương thức đó:

using System;

delegate void Notify(string message);

class Mailbox
{
    private readonly string owner;
    public Mailbox(string owner) { this.owner = owner; }

    public void Receive(string message) => Console.WriteLine($"{owner} got: {message}");
}

class Program
{
    static void Main()
    {
        var ana = new Mailbox("Ana");
        Notify notify = ana.Receive;

        notify("Your order shipped");
        Console.WriteLine($"target: {notify.Target.GetType().Name}, method: {notify.Method.Name}");
    }
}

Đầu ra:

Ana got: Your order shipped
target: Mailbox, method: Receive

Target là đối tượng mà delegate sẽ gọi phương thức trên đó (null với phương thức tĩnh), còn Method mô tả phương thức. Việc giữ target cũng có nghĩa là delegate giữ đối tượng đó sống, điều này quan trọng với event.

Delegate làm callback

Nhiệm vụ chính của delegate là cho một phương thức gọi code mà nơi gọi nó đã chọn. Phương thức quyết định khi nào điều gì đó xảy ra; nơi gọi quyết định điều gì xảy ra:

using System;

delegate void ProgressHandler(int percent);

class Program
{
    static void ImportRows(string[] rows, ProgressHandler onProgress)
    {
        for (int i = 0; i < rows.Length; i++)
        {
            // ... import rows[i] ...
            int percent = (i + 1) * 100 / rows.Length;
            onProgress(percent);
        }
    }

    static void PrintBar(int percent)
    {
        Console.WriteLine($"[{new string('#', percent / 10),-10}] {percent}%");
    }

    static void Main()
    {
        string[] rows = { "a", "b", "c", "d" };

        ImportRows(rows, PrintBar);
        ImportRows(rows, p => { if (p == 100) Console.WriteLine("import finished"); });
    }
}

Đầu ra:

[##        ] 25%
[#####     ] 50%
[#######   ] 75%
[##########] 100%
import finished

ImportRows không biết gì về console hay thanh tiến độ. Cùng một phương thức có thể điều khiển thanh tiến độ, một dòng log hay cập nhật UI, tùy vào thứ nơi gọi truyền vào. List.Sort(Comparison<T>), Array.Find(Predicate<T>), Task.Run(Action) và mọi toán tử LINQ đều theo mẫu này.

Multicast delegate: += và -=

Một delegate có thể giữ nhiều phương thức. += nối thêm một phương thức vào danh sách gọi, -= gỡ nó ra, và gọi delegate sẽ gọi từng phương thức theo thứ tự:

using System;

delegate void OrderPlaced(string orderId);

class Program
{
    static void SendConfirmation(string id) => Console.WriteLine($"email sent for {id}");
    static void UpdateStock(string id) => Console.WriteLine($"stock updated for {id}");
    static void NotifyWarehouse(string id) => Console.WriteLine($"warehouse notified for {id}");

    static void Main()
    {
        OrderPlaced handlers = SendConfirmation;
        handlers += UpdateStock;
        handlers += NotifyWarehouse;

        handlers("A-1001");
        Console.WriteLine($"{handlers.GetInvocationList().Length} handlers");

        handlers -= UpdateStock;
        handlers("A-1002");
    }
}

Đầu ra:

email sent for A-1001
stock updated for A-1001
warehouse notified for A-1001
3 handlers
email sent for A-1002
warehouse notified for A-1002

Ba chi tiết của multicast delegate quan trọng trong thực tế:

• Giá trị trả về: nếu kiểu delegate trả về giá trị, gọi một multicast delegate chỉ trả về kết quả của phương thức cuối cùng. Để lấy mọi kết quả, hãy duyệt GetInvocationList() và tự gọi từng phương thức.
• Ngoại lệ: nếu một phương thức ném ngoại lệ, các phương thức còn lại không chạy và ngoại lệ đi đến nơi gọi.
• Tính bất biến: delegate là bất biến. += tạo một delegate mới với danh sách dài hơn rồi gán lại cho biến, đó là lý do gỡ bằng -= trên một bản sao không ảnh hưởng đến bản gốc.

Gỡ một lambda bằng -= chỉ có tác dụng nếu bạn truyền cùng một instance delegate. Viết cùng một lambda hai lần tạo ra hai delegate khác nhau, nên handlers -= id => Log(id); không gỡ được gì. Hãy lưu lambda vào một biến khi bạn định hủy đăng ký nó.

Delegate null và ?.Invoke

Biến delegate chưa được gán gì là null, và gỡ phương thức cuối cùng bằng -= cũng để lại null. Gọi null sẽ ném NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        Action<string> onSaved = null;

        onSaved?.Invoke("draft.txt");          // nothing happens
        Console.WriteLine("no handler, no crash");

        onSaved += name => Console.WriteLine($"saved {name}");
        onSaved?.Invoke("draft.txt");

        try
        {
            Action<string> missing = null;
            missing("x");
        }
        catch (NullReferenceException e)
        {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

Đầu ra:

no handler, no crash
saved draft.txt
NullReferenceException

?.Invoke là cách chuẩn để gọi một callback tùy chọn. Toán tử ?. không đặt ngay trước dấu ngoặc đơn được (onSaved?("x") là cú pháp không hợp lệ), nên mẫu này gọi phương thức Invoke của delegate theo tên, có tác dụng giống hệt cách gọi viết tắt.

Delegate, Func, Action và event

Khai báo một kiểu delegate cho mỗi chữ ký thì rất mất công, nên .NET có sẵn các kiểu generic:

PriceRule ở ví dụ đầu có cùng hình dạng với Func<decimal, decimal>, nhưng hai kiểu này khác nhau và không chuyển đổi qua lại được. Ngay cả hai kiểu có sẵn với chữ ký giống hệt nhau cũng không:

Func<int, bool> isPositive = x => x > 0;
Predicate<int> p = isPositive;
// error CS0029: Cannot implicitly convert type 'System.Func<int, bool>' to 'System.Predicate<int>'

Predicate<int> ok = new Predicate<int>(isPositive);   // wrap it explicitly
Predicate<int> ok2 = x => isPositive(x);              // or with a lambda

Lambda chuyển đổi được sang mọi kiểu delegate tương thích, nên API thường nhận lambda và câu hỏi này không bao giờ xuất hiện. Trang Func và Action nói về họ kiểu generic này và khi nào khai báo tùy chỉnh vẫn đáng dùng.

Event được xây dựng trực tiếp trên delegate. Một field event là multicast delegate mà code bên ngoài chỉ được += và -=, không bao giờ được gọi hay ghi đè. Danh sách subscriber trong ví dụ multicast ở trên chính là thứ event quản lý giúp bạn, kèm thêm lớp bảo vệ đó. Event được trình bày ở một trang riêng.