Delegate và Event trong C#

Giới thiệu

Trong các ứng dụng Windows Form, khi ta click chuột vào một button hay chọn một mục trong listbox, thì đều phát sinh một sự kiện (event). Chương trình có nhiệm vụ xử lý các sự kiện này, chứ không phải các control button hay listbox xử lý. Chính cơ chế này đã tạo ra khả năng tương tác linh hoạt giữa người dùng và chương trình. Người dùng gửi đến chương trình các yêu cầu thông qua các sự kiện, chương trình đáp ứng sự kiện đó và thực hiện một tác vụ nào đó.

Những sự kiện đó đều được thực thi bởi cơ chế ủy quyền (delegate). Trong bài viết này, tôi sẽ giới thiệu với các bạn khái niệm delegate và cách sử dụng nó để tạo event (sự kiện) trong C#.

Delegate là gì?

Delegate đơn giản chỉ là một kiểu dữ liệu tham chiếu (reference type) dùng để đóng gói một phương thức với tham số và kiểu trả về xác định. Chúng ta có thể đóng gói bất kỳ phương thức nào trong mộtdelegate thích hợp.

Delegate trong C# cũng tương tự như con trỏ hàm trong C++ (function pointer). Bạn sẽ dễ dàng tiếp cậndelegate nếu bạn đã từng sử dụng con trỏ hàm trong C++.

Delegate thường được sử dụng để tạo các sự kiện và các hàm callback cho chương trình.

Khai báo delegate

Cú pháp khai báo delegate trong C# như sau:

1	`chỉ_định_từ_truy_xuất` `delegate` `kiểu_trả_về tên_delegate(danh_sách_tham_số);`

Trong đó:

chỉ_định_từ_truy_xuất: là một trong các thuộc tính truy cập: private, public, protected, internal.
kiểu_trả_về: kiểu trả về của phương thức
tên_delegate: tên của delegate
danh_sách_tham_số: các tham số của phương thức

Chú ý: delegate chỉ mô tả dạng tổng quát của phương thức, bao gồm kiểu trả về và tham số. Còn phương thức cụ thể sẽ được truyền vào thông qua một thể hiện (instance) của delegate. Ví dụ:

1	`public` `delegate` `void` `MyEventHandler(string` `Message);`

Delegate này đại diện cho tập các phương thức có một tham số đầu vào có kiểu string và có kiểu trả về là void.

Để sử dụng delegate, chúng ta phải tạo một thể hiện của nó (tương tự như tạo đối tượng của lớp) và truyền vào phương thức phù hợp (kiểu trả về và tham số) vào hàm khởi tạo của nó. Ví dụ:

using System;
namespace DelegateDemo
{
    public delegate void MyEventHandler(string msg);
    public class Demo
    {
        public static void Main()
        {
            Demo d = new Demo();
            MyEventHandler handler = new MyEventHandler(d.DisplayMsg);
            handler("Display Message Here.");
            Console.ReadLine();
        }
        public void DisplayMsg(string msg)
        {
            Console.WriteLine(msg);
        }
    }
}

Trong ví dụ trên, tôi đã tạo ra một delegate tên là MyEventHandler đại diện cho các phương thức có một tham số đầu vào có kiểu string và có kiểu trả về là void. Sau đó, tôi tạo ra một thể hiện củaMyEventHandler có tên là handler, truyền vào phương thức khởi tạo của nó là DisplayMsg (dòng 12 trong ví dụ minh họa ở trên). Hàm DisplayMsg này có phần khai báo giống với phần khai báo củadelegate MyEventHandler.

Khi các bạn gọi handler và truyền cho nó chuỗi: “Display Message Here.”, nó sẽ gọi hàm DisplayMsgvà truyền chuỗi “Display Message Here.” cho hàm này.

Kỹ thuật Multicasting

C# cho phép chúng ta “gắn” nhiều phương thức vào cùng một delegate, miễn là các phương thức này có cùng kiểu trả về và tham số với delegate. Và khi ta gọi delegate này, tất cả các phương thức đã được “gắn” sẽ thi hành cùng lúc. Kỹ thuật này gọi là “Multicasting”.

Chú ý : Một multicast delegate chỉ chấp nhận phương thức có kiểu trả về là void.

Để thực hiện Multicasting, ta tạo các thể hiện của một multicast delegate, gắn nó với các phương thức tương ứng. Sau đó dùng toán tử “+” để gom các delegate này vào thành 1 delegate duy nhất. Dưới đây là ví dụ minh họa:

using System;
namespace DelegateDemo
{
    public delegate void MyEventHandler(string msg);
    public class Demo
    {
        public static void Main()
        {
            Demo d = new Demo();
            MyEventHandler handler1 = new MyEventHandler(d.DisplayMsg);
            MyEventHandler handler2 = new MyEventHandler(d.DisplayMsg);
            MyEventHandler handler = handler1 + handler2;
            handler("Test");
            Console.ReadLine();
        }
        public void DisplayMsg(string msg)
        {
            Console.WriteLine(msg);
        }
        public void ShowHello(string name)
        {
            Console.WriteLine("Hello " + name);
        }
    }
}

Trong ví dụ trên, đầu tiên, chúng ta tạo ra hai delegate là handler1 và hanlder2 gắn hai hàmDisplayMsg() và ShowHello() vào. Sau đó, chúng ta tạo delegate tên là handler và “cộng” haidelegate handler1 và hanlder2 lại với nhau. Như vậy, khi gọi delegate handler, hai delegatehandler1 và hanlder2 sẽ đồng thời được gọi.

Ngoài toán tử “+”, C# còn hổ trợ toán tử “+=” và “-=” trên delegate. Ví dụ:

using System;
namespace DelegateDemo
{
    public delegate void MyEventHandler(string msg);
    public class Demo
    {
        public static void Main()
        {
            Demo d = new Demo();
            MyEventHandler handler = new MyEventHandler(d.DisplayMsg);
            handler += d.ShowHello;
            handler("Test");
            Console.ReadLine();
        }
        public void DisplayMsg(string msg)
        {
            Console.WriteLine(msg);
        }
        public void ShowHello(string name)
        {
            Console.WriteLine("Hello " + name);
        }
    }
}

Event (sự kiện)

Một trong những ứng dụng thường thấy nhất của delegate là event. Mỗi sự kiện thực chất là mộtdelegate.

Cú pháp khai báo event trong C# như sau:

chỉ_định_từ_truy_xuất event tên_delegate tên_event;

Trong đó:

chỉ_định_từ_truy_xuất: là một trong các thuộc tính truy cập: private, public, protected, internal.
tên_delegate: kiểu của delegate đại diện cho event
tên_event: tên của event

Ví dụ:

1 2	`public` `delegate` `void` `MyEventHandler(string` `msg);` `public` `event` `MyEventHandler Click;`

Sau đó chúng ta có thể phát ra sự kiện (fire event) bằng cách gọi tên sự kiện và truyền tham số tương ứng.
Ví dụ:

namespace DelegateDemo
{
    public delegate void MyEventHandler(string msg);
    public class Window
    {
        public event MyEventHandler Click;
        public Window(int top, int left)
        {
            this.top = top;
            this.left = left;
        }
        // mô phỏng vẽ cửa sổ
        public virtual void DrawWindow() { }
        public void FireEvent()
        {
            if (Click != null)
                Click("Event Fire.");
        }
        // Có hai biến thành viên private do đó hai
        // biến này sẽ không thấy bên trong lớp con
        int top;
        private int left;
    }
    // ListBox dẫn xuất từ Window
    public class ListBox : Window
    {
        public ListBox(int top, int left)
            : base(top, left)
        {
            //Console.WriteLine("Constructor's ListBox have 2 parameter");
        }
        // Khởi dựng có tham số
        public ListBox(int top, int left, string theContents)
            : base(top, left) // gọi khởi dựng của lớp cơ sở
        {
            mListBoxContents = theContents;
        }
        public override void DrawWindow()
        {
            Console.WriteLine("DrawWindow's ListBox");
        }
        // biến thành viên private
        private string mListBoxContents;
    }
    public class Tester
    {
        public static void Main()
        {
            Window w = new Window(100, 100);
            w.Click += w_Click;
            w.FireEvent(); // phát sinh sự kiện
            Console.ReadLine();
        }
        static void w_Click(string msg)
        {
            Console.WriteLine(msg);
        }
    }
}