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

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 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　variation　of　the　　If　function　is　a　two…parameter　version　that　can　be　used　to　test　　

　　　　　　　　　　whether　or　not　an　object　has　a　value　of　　Nothing；　as　follows：　



　　　　　　　　　　　Dim　cleanUpList　=　Function（defaultObject　As　Object）_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Function（objToTest　As　Object）　If（objToTest；　defaultObject）　


…………………………………………………………Page　267……………………………………………………………

　　　　　　　　　　　　　　　　　　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　　245　



　　　　　The　implementation　of　the　lambda　expression　has　an　　If　with　two　parameters。　The　first　　

parameter　is　the　object　to　test　for　Nothing；　and　the　second　parameter　represents　the　expression　　

to　execute　if　the　object　is　Nothing。　　



Learning　More　About　Collection　Types　



In　the　beginning　of　this　chapter；　I　talked　about　the　different　collection　types；　but　not　how　to　use　　

them。　This　section　presents　examples　of　using　the　types。　



Using　a　Plain…Vanilla　List　



A　plain…vanilla　list　is　a　list　of　specific　types　such　as　　Integer；　Double；　or　some　other　object　type。　　

Instantiate　the　list　as　follows：　



Dim　lst　As　List（Of　MyType）　=　New　List（Of　MyType）（）　



　　　　　The　default　type　　List　is　used　for　most　of　your　coding　situations；　but　if　you　are　adding　and　　

removing　elements　frequently；　the　following　code　is　better。　



Dim　lst　As　IList（Of　MyType）　=　New　LinkedList（Of　MyType）（）　



　　　　　The　type　　LinkedList　implements　the　logic　that　was　presented　in　the　previous　chapter；　　

whereas　　List　manipulates　a　fixed…length　array。　　LinkedList　has　a　downside　in　that　it　does　not　　

support　the　IList　interface；　and　the　sample　code　will　not　pile。　Thus；　to　make　the　code　　

work；　you　would　need　to　use　　ICollection：　



Dim　lst　As　ICollection（Of　MyType）　=　New　LinkedList（Of　MyType）（）　



　　　　　Add　an　element　to　　IList　as　follows：　



lst。Add（New　MyType（））　



　　　　　To　add　elements　to　your　list　according　to　an　order；　use　the　following　form　（note　that　　

ICollection　doesn’t　have　this　method）。　



lst。Insert（0；　New　MyType（））　



　　　　　This　adds　an　element　to　the　front　of　the　list。　If　you　are　adding　elements　at　the　beginning　of　　

the　list　or　somewhere　in　the　list；　it　is　better　to　use　the　　LinkedList　type；　as　it　is　more　efficient。　　

Using　the　class　　List　incurs　an　array　copy　resource　penalty。　

　　　　　You　can　also　add　one　list　to　another：　



Dim　lst　As　List（Of　MyType）　=　New　List（Of　MyType）（）　

Dim　lstToBeAdded　As　List（Of　MyType）　

lst。AddRange（lstToBeAdded）　

lst。InsertRange（0；　lstToBeAdded）　



　　　　　The　AddRange（）　method　is　used　to　append　the　list　lstToBeAdded　to　lst。　The　InsertRange（）　　

method　inserts　all　of　the　elements　in　lstToBeAdded　to　the　front　of　the　list　lst。　


…………………………………………………………Page　268……………………………………………………………

246　　　　　　　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　　



　　　　　　　　　　　　　　　　Delete　an　element　from　the　list　like　this：　



　　　　　　　　　　　lst。Remove（existingMyType）　



　　　　　　　　　　　　　　　　The　Remove（）　method　expects　an　instance　of　a　type　to　remove　from　the　list。　　

　　　　　　　　　　　　　　　　To　delete　a　particular　element　at　a　particular　index；　use　the　following　form。　



　　　　　　　　　　　lst。RemoveAt（0）　



　　　　　　　　　　　　　　　　This　code　would　remove　the　element　at　the　front　of　the　list。　



　　　　　　　　　　Using　a　Key/Value　Pair　List　



　　　　　　　　　　A　key/value　pair　list　is　a　list　that　has　a　cross…reference。　It　is　like　a　dictionary　where　you　have　　

　　　　　　　　　　a　word　and　associated　meaning。　In　puting　terms；　the　word　is　a　type　and　its　definition　is　　

　　　　　　　　　　another　type。　The　word　is　a　key　and　the　definition　is　a　value。　A　key/value　pair　definition　would　　

　　　　　　　　　　be　as　follows；　using　the　　IDictionary　interface　and　Dictionary　class。　



　　　　　　　　　　Dim　dictionary　As　IDictionary（Of　String；　Object）　=　_　

　　　　　　　　　　　　New　Dictionary（Of　String；　Object）（）　



　　　　　　　　　　　　　　　You　could　also　use　SortedDictionary；　but　that　implies　the　elements　within　the　list　are　sorted。　

　　　　　　　　　　　　　　　　To　add　values　to　the　dictionary；　use　the　Add（）　method：　



　　　　　　　　　　　　　　　　　　dictionary。Add（〃List〃；　lst）　

　　　　　　　　　　　　　　　　　　dictionary。Add（〃List　To　Be　Added〃；　lstToBeAdded）　



　　　　　　　　　　　　　　　When　working　with　　IDictionary　objects；　you　might　want　to　know　whether　or　not　a　key　is　　

　　　　　　　　　　available。　The　following　code　is　used　to　verify　if　a　key　exists。　



　　　　　　　　　　　If　dictionary。ContainsKey（〃List〃）　Then　

　　　　　　　　　　　　　　。　。　。　

　　　　　　　　　　　End　If　



　　　　　　　　　　　　　　　　If　you　want　to　iterate　the　keys；　use　this　form：　



　　　　　　　　　　　For　Each　key　As　String　In　dictionary。Keys　

　　　　　　　　　　Next　



　　　　　　　　　　　　　　　　Iterate　the　values　as　follows：　



　　　　　　　　　　　For　Each　value　As　Object　In　dictionary。Values　

　　　　　　　　　　Next　



　　　　　　　　　　Using　a　Stack　



　　　　　　　　　　A　　Stack　is　a　special　list　that　behaves　like　a　stack　of　paper　on　a　table。　When　you　add　three　items　　

　　　　　　　　　　on　the　Stack；　the