Ngôn ngữ Csharp phần 9 doc

Ngôn Ngữ Lập Trình C#

public static void Main()

{

Image theImage = new Image();

// do không có GUI để thực hiện chúng ta sẽ chọn lần

// lượt các hành động và thực hiện

ImageProcessor theProc = new ImageProcessor(theImage);

theProc.AddToEffects(theProc.BlurEffect);

theProc.AddToEffects(theProc.FilterEffect);

theProc.AddToEffects(theProc.RotateEffect);

theProc.AddToEffects(theProc.SharpenEffect);

theProc.ProcessImage();

}

}

}

-----------------------------------------------------------------------------

 Kết quả:

An image created

Blurring image

Filtering image

Rotate image

Sharpening image

-----------------------------------------------------------------------------

Trong ví dụ trên, đối tượng ImageProcessor được tạo ra và những hiệu ứng được thêm vào.

Nếu người dùng chọn làm mờ trước khi lọc ảnh, thì đơn giản là được đưa vào mảng ủy quyền

theo thứ tự tương ứng. Tương tự như vậy, bất cứ hành động lựa chọn nào của người dùng

mong muốn, ta đưa thêm nhiều ủy quyền vào trong tập hợp.

Chúng ta có thể tưởng tượng việc hiển thị thứ tự hành động này trong một danh sách listbox

và cho phép người sử dụng sắp xếp lại phương thức, di chuyển chúng lên xuống trong danh

sách. Khi các hành động này được sắp xếp lại thì chúng ta chỉ cần thay đổi thứ tự trong tập

hợp. Ngoài ra ta cũng có thể đưa các hoạt động này vào trong cơ sở dữ liệu rồi sau đó đọc

chúng lúc thực hiện.

Ủ y quyền dễ dàng cung cấp động cho ta các phương thức được gọi theo một thứ tự xác định

Multicasting

Cơ chế multicasting cho phép gọi hai phương thức thực thi thông qua một ủy quyền đơn.

Điều này trở nên quan trọng khi xử lý các sự kiện, sẽ được thảo luận trong phần cuối của

chương.

Cơ Chế Ủy Quyền - Sự Kiện

321

Ngôn Ngữ Lập Trình C#

Mục đích chính là có một ủy quyền có thể gọi thực hiện nhiều hơn một phương thức. Điều

này hoàn toàn khác với việc có một tập hợp các ủy quyền, vì mỗi trong số chúng chỉ gọi được

duy nhất một phương thức. Trong ví dụ trước, tập hợp được sử dụng để lưu giữ các ủy quyền

khác nhau. Tập hợp này cũng có thể thêm một ủy quyền nhiều hơn một lần, và sử dụng tập

hợp để sắp xếp lại các ủy quyền và điều khiển thứ tự hành động được gọi.

Với Multicasting chúng ta có thể tạo một ủy quyền đơn và cho phép gọi nhiều phương thức

được đóng. Ví dụ, khi một nút lệnh được nhấn chúng ta có thể muốn thực hiện nhiều hơn một

hàh động. Để làm được điều này chúng ta có thể đưa cho button một tập hợp các ủy quyền,

nhưng để sáng rõ hơn và dễ dàng hơn là tạo một ủy quyền Multicast.

Bất cứ ủy quyền nào trả về giá trị void là ủy quyền multicast, mặc dù vậy ta có thể đối xử với

nó như là ủy quyền bình thường cũng không sao. Hai ủy quyền Multicast có thể được kết hợp

với nhau bằng phép toán cộng (+). Kết quả là một ủy quyền Multicast mới và gọi đến tất cả

các phương thức thực thi nguyên thủy của cả hai bên. Ví dụ, giả sử Writer và Logger là ủy

quyền trả về giá trị void, dòng lệnh theo sau sẽ kết hợp chúng lại với nhau và tạo ra một ủy

quyền Multicast mới:

myMulticastDelegate = Writer + Logger;

Chúng ta cũng có thể thêm những ủy quyền vào trong ủy quyền Multicast bằng toán tử cộng

bằng (+=). Phép toán này sẽ thêm ủy quyền ở phía bên phải của toán tử vào ủy quyền

Multicast ở bên trái. Ví dụ minh họa như sau, giả sử có Transmitter và myMulticastDelegate

là những ủy quyền, lệnh tiếp theo sau đây sẽ thực hiện việc thêm ủy quyền Transmitter vào

trong myMulticastDelegate:

myMulticastDelegate += Transmitter;

Để hiểu rõ ủy quyền Multicast được tạo ra và sử dụng, chúng ta sẽ từng bước tìm hiểu thông

qua ví dụ 11.3 bên dưới, trong ví dụ minh họa này chúng ta sẽ tạo ra một lớp có tên gọi là

MyClassWithDelegate lớp này định nghĩa một delegate, delegate này lấy một tham số là

chuỗi và không có giá trị trả về:

void delegate void StringDelegate( string s);

Sau đó chúng ta định một lớp gọi là MyImplementingClass lớp này có ba phương thức, tất cả

các phương thức này đều trả về giá trị void và nhận một chuỗi làm tham số: WriteString,

LogString, và Transmitting. Phương thức đầu tiên viết một chuỗi xuất ra màn hình tiêu

chuẩn, chuỗi thứ hai mô phỏng viết vào một log file, và phương thức thứ ba mô phỏng việc

chuyển một chuỗi qua Internet. Chúng ta tạo thể hiện delegate để gọi những phương thức

tương ứng:

Writer(“String passed to Writer\n”);

Logger(“String passed to Logger\n”);

Transmitter(“String passed to Transmitter\n”);

Để xem cách kết hợp các delegate, chúng ta tạo một thể hiện delegate khác:

MyClassWithDelegate.StringDelegate myMulticastDelegate;

Cơ Chế Ủy Quyền - Sự Kiện

322

Ngôn Ngữ Lập Trình C#

và gán cho delegate này kết quả của phép cộng hai delegate cho trước:

myMulticastDelegate = Writer + Logger;

Tiếp theo chúng ta thêm vào delegate này một delegate nữa bằng cách sử dụng toán tử (+=):

myMulticastDelegate += Transmitter;

Cuối cùng, chúng ta thực hiện việc xóa deleagate bằng sử dụng toán tử (-=):

DelegateCollector -= Logger;

Sau đây là toàn bộ ví dụ minh họa.

 Ví dụ 11.3: Kết hợp các delegate.

-----------------------------------------------------------------------------

namespace Programming_CSharp

{

using System;

public class MyClassWithDelegate

{

// khai báo delegate

public delegate void StringDelegate(string s);

}

public class MyImplementingClass

{

public static void WriteString( string s)

{

Console.WriteLine(“Writing string {0}”, s);

}

public static void LogString( string s)

{

Console.WriteLine(“Logging string {0}”, s);

}

public static void TransmitString( string s)

{

Console.WriteLine(“Transmitting string {0}”, s);

}

}

public class Test

{

public static void Main()

{

// định nghĩa 3 StringDelegate

MyClassWithDelegate.StringDelegate Writer, Logger, Transmitter;

Cơ Chế Ủy Quyền - Sự Kiện

323

Ngôn Ngữ Lập Trình C#

// định nghĩa một StringDelegate khác thực hiện Multicasting

MyClassWithDelegate.StringDelegate myMulticastDelegate;

// tạo thể hiện của 3 delegate đầu tiên và truyền vào phương thức thực thi

Writer = new MyClassWithDelegate.StringDelegate(

MyImplementingClass.WriteString);

Logger = new MyClassWithDelegate.StringDelegate(

MyImplementingClass.LogString);

Transmitter = new MyClassWithDelegate.StringDelegate(

MyImplementingClass.TransmitString);

// gọi phương thức delegate Writer

Writer(“String passed to Writer\n”);

// gọi phương thức delegate Logger

Logger(“String passed to Logger\n”);

//gọi phương thức delegate Transmitter

Transmitter(“String passed to Transmitter\n”);

// thông báo người dùng rằng đã kết hợp hai delegate vào

// trong một multicast delegate

Console.WriteLine(“myMulticastDelegate = Writer + Logger”);

// kết hợp hai delegate

myMulticastDelegate = Writer + Logger;

// gọi phương thức delegate, hai phương thức sẽ được thực hiện

myMulticastDelegate(“First string passed to Collector”);

// bảo với người sử dụng rằng đã thêm delegate thứ 3 vào

// trong Multicast delegate

Console.WriteLine(“\nmyMulticastDeleagte += Transmitter”);

// thêm delegate thứ ba vào

myMulticastDelegate += Transmitter;

// gọi thực thi Multicast delegate, cùng một lúc ba

// phương thức sẽ cùng được gọi thực hiện

myMulticastDelegate(“Second string passed to Collector”);

// bảo với người sử dụng rằng xóa delegate Logger

Console.WriteLine(“\nmyMulticastDelegate -= Logger”);

// xóa delegate Logger

myMulticastDelegate -= Logger;

// gọi lại delegate, lúc này chỉ còn thực hiện hai phương thức

myMulticastDelegate(“Third string passed to Collector”);

}// end Main

}// end class

Cơ Chế Ủy Quyền - Sự Kiện

324