VB2008从入门到精通(PDF格式英文版)-第70部分

按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！



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　piler　did　this　by　　

inferring　from　the　code。　

　　　　　Single…expression　lambda　expressions　have　some　use；　but　their　real　value　is　in　the　ability　　

to　create　a　closure　that　establishes　a　context。　A　closure　holds　the　evaluated　lambda　expression　　

with　its　bound　variables　for　other　functions　to　use；　which　is　how　the　context　is　established。　

　　　　　Let’s　say　that　we　are　going　to　calculate　the　sales　tax　for　a　particular　place　like　Quebec；　　

Canada。　The　sales　tax　there　is　15％；　and　thus　when　using　the　lambda　expression；　we　abstract　　

and　create　code　similar　to　the　following。　



Console。WriteLine（〃Tax　（〃　&　calculate（SalesTax。Quebec；　100。0）　&　〃）〃）　



　　　　　The　value　for　the　sales　tax　is　held　in　the　property　SalesTax。Quebec；　and　whenever　we　use　　

the　lambda　expression；　we　need　to　specify　the　property。　　

　　　　　With　lambda　expressions　and　closure；　you　have　the　ability　to　save　a　context。　For　starters；　　

let’s　redefine　the　lambda　expression　to　have　only　a　single　parameter：　



Function（amount　As　Double）　（tax　*　amount）　＋　amount　


…………………………………………………………Page　266……………………………………………………………

244　　　　　　　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　　



　　　　　　　　　　　　　　　　Notice　that　the　lambda　expression　still　uses　the　tax　rate　in　its　calculation。　This　is　where　context　　

　　　　　　　　　　　es　in。　We　can　save　the　context　of　a　certain　tax　rate　and　then　use　the　lambda　expression　in　that　　

　　　　　　　　　　　context。　To　do　so；　we　need　a　lambda　expression　that　returns　our　new　one…parameter　lambda　　

　　　　　　　　　　　expression：　



　　　　　　　　　　　Function（tax　As　Double）　Function（amount　As　Double）　（tax　*　amount）　＋　amount　



　　　　　　　　　　　　　　　　We　can　set　the　tax　rate　with　the　first　lambda　expression；　and　then　call　the　second　to　calcu

　　　　　　　　　　late　the　tax：　



　　　　　　　　　　　Dim　prepareTax　=　

　　　　　　　　　　　　Function（tax　As　Double）　Function（amount　As　Double）　（tax　*　amount）　＋　amount　



　　　　　　　　　　　Dim　doQuebec　=　prepareTax（0。1）　

　　　　　　　　　　　Console。WriteLine（doQuebec（100））　



　　　　　　　　　　　　　　　　The　call　to　prepareTax　defines　doQuebec　as　prepareTax（0。1）　and　sets　the　tax　variable　in　the　　

　　　　　　　　　　　context　of　doQuebec。　Now　when　we　call　doQuebec；　we　can　calculate　the　total　amount　without　　

　　　　　　　　　　　ever　needing　to　specify　the　tax　rate　again。　

　　　　　　　　　　　　　　　　Lambda　expressions　allow　only　a　single　expression。　If　you　want　to　implement　a　lambda　　

　　　　　　　　　　　expression　that　should　make　a　decision；　you　have　a　problem。　To　solve　this　problem；　you　can　　

　　　　　　　　　　use　an　If　statement　variation　that　is　like　a　function。　Imagine　a　country　where　the　applicable　　

　　　　　　　　　　　sales　tax　depends　on　the　amount　you　purchased。　This　logic　could　be　implemented　using　a　　

　　　　　　　　　　　closure　and　ternary　If　statement；　as　follows：　



　　　　　　　　　　　Dim　setMinimumSalesTax　=　Function（minimumSalesTax　As　Double）　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Function（amount　As　Double）　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　If（amount　》　minimumSalesTax；　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（0。15　*　amount）　＋　amount；_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（0。1　*　amount）　＋　amount）　



　　　　　　　　　　　Dim　calculateTotal　=　setMinimumSalesTax（100）　



　　　　　　　　　　　Console。WriteLine（calculateTotal（80））　

　　　　　　　　　　　Console。WriteLine（calculateTotal（500））　



　　　　　　　　　　　　　　　　The　ternary　　If　is　a　function　that　has　three　parameters。　The　first　parameter　is　the　expres

　　　　　　　　　　　sion　you　want　to　test。　Typically；　whatever　you　would　write　in　a　regular　If　block；　you　would　　

　　　　　　　　　　write　as　the　first　parameter。　In　the　example；　it　is　a　test　of　whether　or　not　the　bought　amount　　

　　　　　　　　　　is　greater　than　a　minimum　amount。　The　second　parameter　is　an　expression　that　is　executed　　

　　　　　　　　　　whenever　the　first　parameter　results　in　a　True　value。　The　third　parameter　executes　if　the　first　　

　　　　　　　　　　parameter　results　in　a　False　value。　

　　　　　　　　　　　　　　　　Another　var