|
|
假定您在为一家新计算机公司起草业务计划，面对如何处理产品分发的问题。当然，您从未考虑过亲自将每一件新产品交付到每位客户的手中。相反，您会将此责任委托给像 FedEx 或 UPS 等配送服务机构。您必须事先做三个决定：该行动是什么（交付产品）、参数是什么（客户地址）以及返回值是什么（付款）。然后，当实际有一个包裹要交付时，您就可以将责任委托给某个特定的配送服务机构。
在 Microsoft .NET 编程中，您会面对需要执行某种特定操作，但是无法预先知道将调用何种方法来执行该操作的情况。例如，在单击某个按钮时，可能需要调用某个方法，但是在设计该按钮时，却无法知道将调用哪个方法。您需要有一种方法来描述要调用何种方法。这正是委托派上用场的地方。在本文中，我将探索如何在 Visual Basic .NET 中使用委托。
入门
委托是一种引用类型，表示带有特定签名和返回类型的方法。可以在该委托中封装任何匹配的方法。另外，还可以将委托看作是对方法的引用。
要了解其工作方式，我们来看一个委托解决的问题。正如您将在图 1 中看到的，我将创建一个 Pair 类的简单集合，其中有两个对象。Pair 类创建一个名为 thePair 的私有数组，其中包括两个成员：
Public Class Pair
Private thePair(2) As Object
构造函数接受两个对象，然后按接收顺序将其添加到此内部数组中：
Public Sub New(ByVal firstObject As Object, ByVal secondObject As Object)
thePair(0) = firstObject
thePair(1) = secondObject
End Sub
Pair 提供其它三种方法：Sort、ReverseSort 以及 ToString 的重写。Sort 方法将对内部数组中的两个对象进行排序。当然，您不希望让 Pair 类知道对这两个对象进行排序的测试，因为实际上您可能在 Pair 中存储任何类型的对象（Students、Dogs、Employees、Buttons，等等）。Pair 如何才能知道如何对所有这些不同类型的对象进行排序呢？
解决方案是将责任（确定哪个对象最小）委托给对象自己。Pair 如何实现这一点？使用委托（参见图 1）。
在 Pair 类中，我已经定义了一个委托以封装（引用）比较两个对象的方法，然后确定哪个较小（不管“较小”是如何定义的，确定的比较类都是合适的）：
Public Delegate Function WhichIsSmaller( _
ByVal obj1 As Object, ByVal obj2 As Object) As Comparison
这是一个相当复杂的定义。让我们来一段一段地查看这个定义：
• Public 关键字将该委托声明为 Pair 类的一个公共成员。
• Delegate 关键字表示您正在创建一个委托（而不是一个方法或属性）。
• Function 关键字表示该委托将用于封装一个函数（而不是一个子程序）。
• WhichIsSmaller 标识符是该委托的名称。
• 括号内的值是该委托将封装的方法的签名。即该委托可能封装任何接受两个对象作为参数的函数。
• 最后的关键字 As Comparison 是该委托可能封装的方法的返回类型。Comparison 是一个在 Pair 类中定义的枚举：
Public Enum Comparison
theFirst = 1
theSecond = 2
End Enum
用该委托封装的方法必须返回 Comparison.theFirst 或 Comparison.theSecond。
总之，刚刚展示的语句在名为 WhichIsSmaller 的 Pair 类中定义了一个公共委托，它封装接受两个对象作为参数的函数并返回 Comparison 枚举类型的一个实例。
可以在该委托的实例中封装任何匹配的方法。例如，您的 Pair 集合可能包含两个 Student 对象，如下所示：
Public Class Student
Private name As String
Public Sub New(ByVal name As String)
Me.name = name
End Sub
' other Student methods here
End Class
您的 Student 类必须创建一个与 WhichIsSmaller 委托相匹配的方法。例如，您可以创建一个 WhichStudentIsSmaller 方法（参见图 2 中的代码）。该方法匹配所要求的签名；它接受两个对象作为参数，并且返回一个 Comparison 值。
因为我的 WhichStudentIsSmaller 方法需要将这些参数用作 Student 对象，而不是作为更一般的 Object 类型，我将把这些参数强制转换为 Student。这是类型安全的，因为我决不会用其他任何类型的参数来调用该方法。
一旦我强制转换了这两个对象，我就可以对它们进行比较。在本例中，我将按字母顺序比较它们的名称值，并返回合适的枚举值：Pair.Comparison.theFirst 或 Pair.Comparison.theSecond。
按字母顺序的比较是通过调用 String 类的共享方法 Compare 来完成的。如果按照字母表，第一个字符串排在第二个前面（s1.name 的字母顺序在 s2.name 之前），则 Compare 返回一个负整数值。如果按照字母表，第二个字符串排在第一个前面，则 Compare 返回一个正整数值，如果相同则返回零。
其他类也能创建与 WhichIsSmaller 委托相匹配的方法。例如，我还可以创建 Dog 类：
Public Class Dog
Private weight As Integer
Public Sub New(ByVal weight As Integer)
Me.weight = weight
End Sub
' other Dog methods here
End Class
该 Dog 类将实现一个方法，基于重量对两个 Dog 实例进行比较：
Public Shared Function WhichDogIsSmaller( _
ByVal o1 As Object, ByVal o2 As Object) As Pair.comparison
Dim d1 As Dog = DirectCast(o1, Dog)
Dim d2 As Dog = DirectCast(o2, Dog)
If d1.weight > d2.weight Then
Return Pair.Comparison.theSecond
Else
Return Pair.Comparison.theFirst
End If
End Function
现在该 Pair 类就可以创建其 Sort 方法了。它将接受一个 WhichIsSmaller 委托作为参数：
Public Sub Sort(ByVal theDelegatedFunc As WhichIsSmaller)
If theDelegatedFunc(thePair(0), thePair(1)) = _
Comparison.theSecond Then
Dim temp As Object = thePair(0)
thePair(0) = thePair(1)
thePair(1) = temp
End If
End Sub
Sort 方法通过委托来调用委托的方法，传递 Pair 数组的两个成员，返回一个枚举值。如果该值为 Comparison.theSecond，就知道第二个对象比第一个类型小。Sort 方法甚至无需知道这两个对象的类型就可以知道这一点！然后它可以将这两个对象颠倒过来。如果委托的方法返回 Comparison.theFirst，则无需交换。
实例化委托
要对此进行测试，可以创建两个 Student 对象，如下所示：
Dim Jesse As New Student("Jesse")
Dim Stacey As New Student("Stacey")
然后将其添加到一个新的 Pair 对象中： Dim studentPair As New Pair(Jesse, Stacey)随后，可以实例化一个 WhichIsSmaller 委托，传递知道如何比较这两个 Student 对象的 Student 的匹配方法：
Dim theStudentDelegate As New _
Pair.WhichIsSmaller(AddressOf Student.WhichStudentIsSmaller)
现在我可以将这个委托传递给 Sort 方法，以便对这个两个学生进行排序：
studentPair.Sort(theStudentDelegate)
类似地，我可以创建两个 Dog 对象，将其添加到 Pair，并基于比较两个 Dog 的 Dog 方法实例化一个委托，然后将该委托传递给 Dog 对的排序方法，如以下各行所示：
' make two dogs
Dim Milo As New Dog(65)
Dim Fred As New Dog(12)
' store the two dogs in a Pair
Dim dogPair As New Pair(Milo, Fred)
' instantiate a delegate
Dim theDogDelegate As New _
Pair.WhichIsSmaller(AddressOf Dog.WhichDogIsSmaller)
' invoke Sort, pass in the delegate
dogPair.Sort(theDogDelegate)
Pair 类有一个接受相同的委托作为 Sort 的 ReverseSort。我同样可以将您刚刚创建的 Student 和 Dog 委托传递给 ReverseSort：
studentPair.ReverseSort(theStudentDelegate)dogPair.ReverseSort(theDogDelegate)
您可能已经猜到了，ReverseSort 的逻辑与 Sort 的逻辑相反。即，仅在比较方法返回的值指示第一个对象比第二个对象小的情况下，才交换 Pair 中的这两项。
实例方法与委托
在图 1所示示例中，封装了 Dog 和 Student 类的共享方法。相反，可以同样容易地将封装的方法声明为实例方法（即，非共享方法）：
Public Comparison
WhichStudentIsSmaller(o1 as Object, o2 as Object)
尽管可以将该方法封装在委托中，但是必须通过实例而不是通过类来引用它，如下所示：
Dim theStudentDelegate As _
New Pair.WhichIsSmaller(AddressOf Jesse.WhichStudentIsSmaller)
尽管重复调用一个封装了实例方法的委托比调用一个静态方法效率更高，您还是需要一个实例来调用该方法。
共享委托
中声明委托的方法的一个缺点是，调用类 (Tester) 必须实例化所需的委托，以便对 Pair 中的对象进行排序。例如，在图 1中 Tester 的 Run 方法中，您可以看到以下代码行：
Dim theStudentDelegate As New _
Pair.WhichIsSmaller(AddressOf Student.WhichStudentIsSmaller)
需要有 Tester 对象才能知道所需方法是 WhichStudentIsSmaller，但这应该是 Tester 对象不可见的 Student 类的实现细节。
可以通过让委托实例成为 Student 类的共享成员来解决这一问题。这样，Tester 类无需知道哪个方法将处理 Student（或 Dog）的排序，只需知道 Student 类有一个共享委托（例如名为 OrderStudents）。然后，就可以按如下所示重新编写 Run 方法：
studentPair.Sort(Student.OrderStudents)
在 Student 类内，共享委托声明如下：
Public Shared ReadOnly OrderStudents As _
New Pair.WhichIsSmaller(AddressOf Student.WhichStudentIsSmaller)
同样，可以在 Dog 类中声明一个静态委托：
Public Shared ReadOnly OrderDogs As New Pair.WhichIsSmaller( _
AddressOf Dog.WhichDogIsSmaller)
现在 Tester 的 Run 方法可以通过编写如下代码来对 Dog 对进行排序：
dogPair.Sort(Dog.OrderDogs)
Delegates As Properties
共享委托的问题在于它们必须被实例化，不管是否使用它们，与前面示例中的 Student.OrderStudents 和 Dog.OrderDogs 一样。这些类可以通过将共享委托字段更改为属性来进行改进，如下所示：
Public Shared ReadOnly Property OrderStudents As Pair.WhichIsFirst
Get
Return New Pair.WhichIsFirst(AddressOf WhichStudentComesFirst)
End Get
End Property
委托的赋值不变：
studentPair.Sort(Student.OrderStudents)
然而关键的不同之处在于，现在，仅当实际访问属性时才实例化委托。
多路广播
在某些情况下，您可能希望通过单个委托调用不只一个而是两个或多个方法。这称为多路广播。通过在委托中封装各种方法可以实现多路广播，然后使用 Delegate.Combine 共享方法合并委托。Combine 方法接受一个委托数组作为参数，返回一个新的委托来代表数组中所有委托的合并。
为了解其工作方式，在以下代码中，我将创建一个简化的类来声明一个委托：
Public Class MyClassWithDelegate
' the delegate declaration
Public Delegate Sub StringDelegate(ByVal s As String)
End Class
然后可以创建一个类，实现匹配 StringDelegate 的多个方法：
Public Class MyImplementingClass
Public Shared Sub WriteString(ByVal s As String)
Console.WriteLine("Writing string {0}", s)
End Sub
Public Shared Sub LogString(ByVal s As String)
Console.WriteLine("Logging string {0}", s)
End Sub
Public Shared Sub TransmitString(ByVal s As String)
Console.WriteLine("Transmitting string {0}", s)
End Sub
End Class
在 Tester 类的 Run 方法中，我将实例化三个 StringDelegate 对象：
Dim Writer, Logger, Transmitter As MyClassWithDelegate.StringDelegate
我通过传递要封装的方法的地址来实例化这些委托，如下所示：
Writer = New MyClassWithDelegate.StringDelegate( _
AddressOf MyImplementingClass.WriteString)
Logger = New MyClassWithDelegate.StringDelegate( _
AddressOf MyImplementingClass.LogString)
Transmitter = New MyClassWithDelegate.StringDelegate( _
AddressOf MyImplementingClass.TransmitString)
接着，实例化用于合并其他三个委托的多路广播委托：
Dim myMulticastDelegate As MyClassWithDelegate.StringDelegate
创建一个包含前两个委托的数组：
Dim arr() As MyClassWithDelegate.StringDelegate = {Writer, Logger}
然后使用该数组来实例化多路广播委托：
myMulticastDelegate = _
DirectCast(System.Delegate.Combine(arr), _
MyClassWithDelegate.StringDelegate)
DirectCast 用于将 Combine 调用的结果转换为专用类型 MyClassWithDelegate.StringDelegate，因为 Combine 返回更一般的 Delegate 类型的对象。本例的完整代码可在本文顶部链接处的下载中找到。
可以通过调用重载的 Combine 方法将第三个委托添加到集合中，这一次传递现有的多路广播委托和要添加的新委托：
myMulticastDelegate = _
DirectCast(System.Delegate.Combine(myMulticastDelegate, Transmitter), _
MyClassWithDelegate.StringDelegate)
可以仅仅删除 Logger 委托，方法是调用静态方法 Remove，并传递多路广播委托和要删除的委托。返回值是一个强制转换为 StringDelegate 的委托，并被分配回多路广播委托，如下所示：
myMulticastDelegate = _
DirectCast(System.Delegate.Remove(myMulticastDelegate, Logger), _
MyClassWithDelegate.StringDelegate)
委托与回调机制
洗衣有两种方法。第一种是将要洗的衣物放入洗衣机，倒入一些洗衣粉，然后等待机器运转。您等啊等。大约 30 分钟以后，机器停止运转，取出衣物。
第二种洗衣方法是将衣物送到洗衣店，然后对服务人员说，“请将这些衣服洗干净，洗完后给我打电话。这是我的手机号码。”当您离开去做其他事情的时候，洗衣店的服务人员为您做这项工作。衣服洗好后，他们就打电话告诉您“您的衣服洗干净了。您的取衣号码是 123。”您回来以后，向服务台的人员出示号码 123，然后取回了衣服。这种策略称为回调。
.NET 框架支持异步回调概念。回调的想法是，您对一个方法说“做这项工作，做完后就给我打电话。”对于多任务技术而言，这是一种简单明了的机制。例如，打开一个文件，然后从中读取数据非常耗费时间。您更希望告诉负责读取文件的对象“去从这个文件读取信息，完成后告诉我”，而您可以走开去做完全不相干的事情。
.NET Framework 为这种服务提供了 FileStream 类。该类将为您异步打开并读取文件，还将在从文件中获取数据后之回调指定的方法。
在图 3 所示的下一个示例中，我打开一个 FileStream 对象，传递文件名、fileMode (Open)、FileAccess 标志 (Read) 以及 FileShare 模式 (ReadWrite)。还将传递表示缓冲区大小的整数以及指示 FileStream 是否应该异步打开的布尔值：
inputStream = New FileStream( _
"C:\temp\streams.txt", _
FileMode.Open, _
FileAccess.Read, _
FileShare.ReadWrite, _
1024, _
True)
如图 3中的示例所示，文件名被硬编写为 c:\temp 子目录中的 streams.txt。在产品代码中，您可能要求用户指定一个文件。如果您正在测试该程序，则应该使用磁盘上已有的文本文件名来替换该文件路径。
既然我有了一个 FileStream 对象，就可以调用它的 BeginRead 方法，该方法提供对文件的异步读取，即在将文本块读入内存的同时执行其它代码。必须传递一个缓冲区，以便有地方存放数据，同时将开始读取位置的偏移量传递到该缓冲区中。还必须传递缓冲区的长度，并告知 BeginRead 要回调的方法。
通过传递委托来指定要回调的方法。我将在下一个示例中创建该委托作为类的成员：
Private myCallBack As AsyncCallback
委托类型已由 FileStream 类的设计人员确定，它指定必须在 AsyncCallback 类型的委托中进行传递。AsyncCallback 委托在文档中定义如下：
Public Delegate Sub AsyncCallback( _
ByVal asyncResult As IAsyncResult)
AsyncCallback 委托是一个子例程（因而不返回值），它接受自己的一个参数作为实现 IAsyncResult 接口的对象。您不必自己来实现该接口。只需创建一个方法，该方法声明一个 IAsyncResult 类型的参数。这种对象将通过 FileStream 的 BeginRead 方法传递给您，同时您需要通过调用 EndRead 将它作为令牌返回到 FileStream。以下是在 AsyncCallback 委托中封装的方法的声明：
Sub OnCompletedRead(ByVal asyncResult As IAsyncResult)
End Sub 'OnCompletedRead
我将构造函数中的委托实例化为类：
myCallBack = New AsyncCallback(AddressOf OnCompletedRead)
此外，您还可以简单地编写以下代码：
myCallBack = AddressOf OnCompletedRead
编译器将基于 myCallBack 的声明类型得知您在实例化 AsyncCallback 委托。
现在可以开始回调过程。通过调用 BeginRead 来开始使用测试类的 Run 方法：
Sub Run()
inputStream.BeginRead( _
buffer, _
0, _
buffer.Length, _
myCallBack, _
Nothing)
第一个参数是一个缓冲区，在本例中声明为一个成员变量，如下所示：
Private buffer() As Byte
第二个参数是相对该缓冲区的偏移量。通过输入 0，从磁盘读取的数据将写入以偏移量 0 开始的缓冲区。第三个参数是缓冲区的长度。第四个参数是先前已经声明和实例化的 AsyncCallBack 委托。第五个也就是最后一个参数可以是您喜欢的任何对象（或者是 Nothing），它通常用于存放调用对象的当前状态。在本例中，您传递 Nothing，一个 Visual Basic .NET 关键字，指示您没有状态对象。
在调用 BeginRead 之后，程序就可以进行其他工作了。在图 3所示的示例中，该工作通过计数到 50 万来进行模拟：
Dim i As Long
For i = 0 To 499999
If i Mod 1000 = 0 Then
Console.WriteLine("i: {0}", i)
End If
Next i
FileStream 将开始工作，为您打开文件。然后它将读取文件，并填充缓冲区。准备好处理数据以后，将调用在委托中封装的方法。记住该委托方法名为 OnCompletedRead：
Sub OnCompletedRead(ByVal asyncResult As IAsyncResult)
Dim bytesRead As Integer = inputStream.EndRead(asyncResult)
' if we got bytes, make them a string
' and display them, then start up again.
' Otherwise, we're finished.
If bytesRead > 0 Then
Dim s As String = Encoding.ASCII.GetString(buffer, 0, bytesRead)
Console.WriteLine(s)
inputStream.BeginRead(buffer, 0, buffer.Length, myCallBack,
Nothing)
End If
FileStream 调用我的方法时，它将传递一个实现 IAsyncResult 接口的类的实例。该方法所做的第一件事就是将 IAsyncResult 对象传递给 FileStream 的 EndRead 方法。EndRead 返回一个整数，指示从文件中成功读取的字节数。如果该值大于 0，则缓冲区中有数据。
虽然缓冲区中存有字节，但需要一个字符串才能显示。通过 Encoding.ASCII.GetString 静态方法（该静态方法接受缓冲区、偏移量以及读取的字节数），可以将缓冲区转换为字符串，并返回一个 ASCII 字符串。然后可将该字符串显示到控制台。
最后，再次调用 BeginRead，传递回缓冲区、偏移量（再次为 0）、缓冲区长度、委托以及用于状态对象的 Nothing。这就又开始了另一轮循环。然后，控制将返回到 Run 方法，代码将继续对字节计数。
我已经在未独立进行实例化或管理任何线程的情况下实现了多路广播任务处理，我只是编写了回调机制，并让 FileStream 进行线程管理。
委托和事件
当用户按下应用程序中的按钮时，您需要得到通知。当用户关闭窗口、在文本框中更改文本、在列表框中进行选择时，您需要得到通知。这些事情称作事件。基于 Windows 的程序是事件驱动的，自从 Windows 开始，Windows 开发程序员一直在与事件打交道。
.NET 环境将事件作为第一类对象，并使用委托来实现事件。Visual Basic .NET 虽然隐藏了实现事件的许多细节，但委托仍未露面。请考虑以下情形：
AddHandler myButton.Click, AddressOf MyButton_Click
这其实是以下代码的简写形式：
AddHandler myButton.Click, New EventHandler(AddressOf MyButton_Click)
EventHandler 是隐式定义的委托的名称。通常，.NET 中的事件处理委托有以下形式：
Public Delegate Event (sender as Object, e as EventArgs)
该委托封装了一个接受两个参数的方法。第一个参数是 sender，表示引起事件的对象。第二个参数 e 是一个 EventArgs 类型的对象或由 EventArgs 派生的类的一个对象。EventArgs 对象通常包含对处理事件的方法有用的附加信息。例如，您可能有一个 clock 对象，每当秒改变一次时就激发一个事件。然后，您可能创建一个 ClockEventArgs 类，并用它来传递从时钟最初启动或重置以来过去的时间。
当您调用 RaiseEvent 时，您是在调用 EventHandler（隐式创建的委托）上的 Invoke。
隐藏的委托
原来公共语言运行库 (CLR) 和编译器在努力协同工作，以使您的委托正常工作。例如，中，当我声明一个委托时
Public Delegate Function WhichIsSmaller( _
ByVal obj1 As Object, ByVal obj2 As Object) As comparison
编译器实际创建一个完整的类定义来支持该委托，这有点类似于图 4 中的代码。
在检查 ILDASMsee 中的 Pair 应用程序（如图 5 所示）时，您可以看到这个类。ILDASM 是随 .NET Framework SDK 提供的中间语言反汇编程序，用作检查编译器产生的中间语言代码的工具。
为委托指定嵌套类，该嵌套类有在外部类 (Pair) 中声明的访问类型 (public) 的委托。该类及其构造函数和三个方法，由编译器代表您创建。WhichIsSmaller 由 MulticastDelegate 派生而来，因此继承了其基类的方法与属性。
所创建的类包含一个采用两个参数的构造函数。第一个是对对象的引用，第二个是代表回调方法的整数。创建委托时，我编写了如下代码：
Dim theStudentDelegate As New _
Pair.WhichIsSmaller(AddressOf Student.WhichStudentIsSmaller)
您可能感到奇怪，这一个参数（Student.WhichStudentIsSmaller 的地址）怎么可以与委托的构造函数的两个参数相匹配呢？编译器知道我在创建一个委托，它将委托的参数解析为对象 (Student) 和方法 (whichStudentIsSmaller)，然后编译器进行转换。
检查委托函数的调用。在 Pair 类中，可以找到一个 Sort 方法，该方法接受 Delegate 作为参数，如下所示：
Public Sub Sort(ByVal theDelegatedFunc As WhichIsSmaller)
在该方法中，可以调用委托的方法，并传递所需参数：
theDelegatedFunc(thePair(0), thePair(1))
当编译器看到对该委托的调用时，将生成如下代码：
WhichIsSmaller.Invoke(thePair(0), thePair(1))
即，编译器调用嵌套委托类的 Invoke 方法。如果在ILDASM 中双击 Pair 对象的 Sort 方法，则将发现以下代码行：
IL_001c: callvirt instance valuetype Pair.DelegatesAndEvents.comparison
Pair.DelegatesAndEvents.Pair/WhichIsSmaller::Invoke(object,object)
委托与多路广播委托
最初的设计原则是，单路广播委托将从 Delegate 类派生，并且可以是子程序或函数，而多路广播委托将从 MulticastDelegate 类派生，并且只能是子程序。这是有道理的，因为如果调用多个方法，则返回一个值是没有意义的。在 beta 测试中，Microsoft 认定这样太混乱，因此现在所有委托都从 MulticastDelegate 派生。用于多路广播的多路广播委托通常将封装子程序（而不是函数）。可以封装函数，但必须忽略其返回值或者调用委托的 GetInvocationList 方法，并手动调用每个委托。
小结
如果您正在使用 Visual Basic .NET，则在创建事件时完全可以忽略委托。可以使用 With Events 和 AddHandler 关键字，让 Visual Basic .NET 去为您处理细节问题。然而，如果您正在创建和使用回调机制，则委托将非常重要。了解一种语言在幕后的工作总是有益的。
|
|
