按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
implementations must match this signature （in our case； ProcessMaximumValue（） and
ProcessRunningTotal（） match the delegate signature）：
Delegate Sub ProcessValue（ByVal value As Integer）
The declaration of the delegate is outside the scope of a class or interface； but the usage of
a delegate must be in the context of a class （as it is in our case）。
The type of the delegate is the name of the method； which is ProcessValue in our case。 The
delegate will be used in the code example to provide a general callback mechanism in the iterator。
The iterator is declared as follows：
…………………………………………………………Page 263……………………………………………………………
C HA P TE R 9 ■ L E AR N I N G A B O U T L I ST S； DE L E G AT E S ； AN D L A M B D A E X PR E SSI O N S 241
Module Extensions
Public Sub Iterate（ByVal collection As ICollection（Of Integer）； _
ByVal cb As ProcessValue）
Dim element As Integer
For Each element In collection
cb（element）
Next
End Sub
End Module
A module method can be called as follows：
Iterator。Iterate（lst； delegate）
The first parameter of the Iterate（） method is the list to iterate； and the second parameter
is a delegate instance that matches the method signature of the ProcessValue delegate。
In the implementation of Iterate（）； each element of the collection is iterated using For
Each； and then in the loop； the variable cb is called as if it were a method。 The calling of cb is
what separates the iterator from the processing of the iteration。 Imagine having implemented
a method that calculates the running total or maximum。 To iterate all of the elements； you
would instantiate the delegate with the method and call Iterate（）； as follows：
Iterator。Iterate（lst； New ProcessValue（ProcessRunningTotal））
。 。 。
Iterator。Iterate（lst； New ProcessValue（ProcessMaximumValue））
The code that wants to automatically iterate code must provide only a delegate imple
mentation。
Implementing Methods That Match the Delegate
Implementing methods that match a delegate is straightforward in that you need to declare
only a method in a class that has the same method signature。 This can be implemented using
a shared method or an instance method； it does not matter。 The following code demonstrates
methods that match the ProcessValue delegate’s signature using both types of methods。
Class DelegateImplementations
Private Sub InstanceProcess（ByVal value As Integer）
End Sub
Private Shared Sub SharedProcess（ByVal value As Integer）
End Sub
End Class
In the example； the InstanceProcess（） and SharedProcess（） methods match the signature
of the delegate ProcessValue。 If you have two delegates with identical parameter and return
type signatures； then a method with the same signature can be used for either delegate definition。
The following shows how to have the methods be recognized as a delegate。
…………………………………………………………Page 264……………………………………………………………
242 CH AP T E R 9 ■ L E A R N IN G AB OU T L I ST S； D E L E G A T E S； A N D L A M B DA E X P R E S SI ON S
Dim instanceMethod As New ProcessValue（AddressOf InstanceProcess）
Dim sharedMethod As New ProcessValue（AddressOf SharedProcess）
These two lines instantiate the delegate using the New keyword； and each instantiation has
a single constructor parameter； which is the method to associate with the delegate instance。
Now let’s look at the running total and maximum value example and see the methods that
will be wrapped up by delegates。
Module Tests
Private _maxValue As Integer
Private _runningTotal As Integer
Private Sub ProcessMaximumValue（ByVal value As Integer）
If （value 》 Tests。_maxValue） Then
_maxValue = value
End If
End Sub
Private Sub ProcessRunningTotal（ByVal value As Integer）
_runningTotal = _runningTotal ＋ value
End Sub
End Module
The ProcessMaximumValue（） and ProcessRunningTotal（） methods both have the same
signatures as ProcessValue； and therefore are delegate candidates。 In each delegate implemen
tation； the running total is calculated or the maximum value is found。 The following code uses
the delegates。
Public Sub RunAll（）
Dim lst As New List（Of Integer）（）
lst。Add（1）
lst。Add（2）
lst。Add（3）
lst。Add（4）
_runningTotal = 0
Iterator。Iterate（lst； New ProcessValue（AddressOf ProcessRunningTotal））
Console。WriteLine（（〃Running total is （〃 & _runningTotal & 〃）〃））
_maxValue = Integer。MinValue
Iterator。Iterate（lst； New ProcessValue（AddressOf ProcessMaximumValue））
Console。WriteLine（（〃Maximum value is （〃 & _maxValue & 〃）〃））
End Sub
In the example； the RunAll（） method instantiates and assigns lst。 Then to iterate the indi
vidual elements； the Iterator。Iterate（） method is called with lst and the
ProcessRunningTotal（） method。 After having calculated and presented the running total； the
maximum value is calculated and displayed。
…………………………………………………………Page 265……………………………………………………………
C HA P TE R 9 ■ L E AR N I N G A B O U T L I ST S； DE L E G AT E S ； AN D L A M B D A E X PR E SSI O N S 243
The delegate solution is more pact than the previous abstract base class solution。 The
big advantage is the ability to solve a problem using a smaller； piecemeal approach。 It is not
hard to implement a delegate； and it is not hard to use a delegate。
Understanding Lambda Expressions
Lambda expressions are an extension of delegates； but solve a specific problem。 Let’s take the
example of calculating sales tax。 Sales tax in general is a simple calculation in that you take the
total amount； multiply it by the sales tax； and add the result to the amount。 This gives you the
total a customer must pay。 Calculating a sales tax is not difficult； but it is something that would
be nice to encapsulate into a small piece of functionality。 Thus； calculating sales tax is an excel
lent use of lambda expressions。
A lambda expression is declared as a Function that has a single expression as a body。 Following
is the declaration of a lambda expression。
Dim calculate = Function（tax As Double； amount As Double） （tax * amount） ＋ amount
The lambda expression is declared as a function without a return type。 The code after the
brackets is a single expression that uses the parameters to perform some action。 In the example；
that single expression is the calculation of the sales tax that is added to the amount to generate
a new total。
The lambda expression could be used as follows：
Console。WriteLine（〃Tax （〃 & calculate（0。1； 100） & 〃）〃）
The calculate lambda expression is called with two numbers that are of type Double； which
generates an expression similar to this：
Function sdfsdfsdf（tax As Double； amount As Double） As Double
Return （tax * amount） ＋ amount
End Function
Notice a return type of Double is declared in the generated code。 The pile