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

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！



of　type　IDefinition。　

　　　　　Is　it　correct　to　assume　that　the　dynamic　loading　of　a　type　can　fulfill　the　contract　of　DoIt（）？　　

Can　you　assume　that　the　type　even　supports　IDefinition？　

　　　　　What　convention　over　configuration　attempts　to　do　is　create　pockets　of　self…contained　　

functionality　that　can　take　care　of　themselves。　That　self…contained　functionality　may　require　　

configuration　file　settings；　and　it　may　require　other　assemblies。　But　what　it　does　not　require　is　　

a　directive　that　includes　source　code　that　explicitly　states　what　to　do　when。　　

　　　　　Consider　a　workplace　scenario。　Instead　of　having　a　manager　tell　the　workers　what　to　do　at　　

every　step；　a　certain　amount　of　peer…to…peer　intelligence　and　self…reliance　are　assumed。　The　　

self…reliance　is　both　good　and　bad。　It　is　good　in　that　there　are　fewer　moving　parts；　but　bad　in　　

that　the　peers　might　be　doing　something　that　they　should　not。　

　　　　　The　following　code　shows　an　example　of　convention。　



Interface　Imand　　

　　　　Sub　Run（）　

End　Interface　

。　。　。　

ConfigurationLoader。Instance。Load（）　

Dim　definition　As　IDefinition　=　_　

　　ConfigurationLoader。Instance。Instantiate（Of　Imand）（〃Impl1〃）　

definition。Run（）　


…………………………………………………………Page　360……………………………………………………………

338　　　　　　　CH　AP　T　E　R　　　1　2　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　A　PP　L　I　CA　TI　O　N　　　CO　N　F　I　G　U　R　AT　IO　N　　　AN　D　　　D　Y　N　A　M　I　C　　L　O　AD　I　N　G　



　　　　　　　　　　　　　　　　The　code　runs　some　other　code　via　the　Run（）　method　and　does　not　have　any　return　values　　

　　　　　　　　　　　or　parameters。　The　code　doing　the　executing　is　hoping　that　everything　will　work　out；　because　　

　　　　　　　　　　it　cannot　check　a　return　value。　And　that　is　the　gist　of　convention　over　configuration—the　　

　　　　　　　　　　　calling　code　hopes　everything　will　work　out。　　

　　　　　　　　　　　　　　　　For　the　most　part；　convention　works　out　quite　nicely　because　it　is　easier　to　extend　and　　

　　　　　　　　　　maintain　a　convention…based　system；　since　there　are　fewer　moving　parts。　For　any　plex　　

　　　　　　　　　　　system；　the　fewer　moving　parts　the　better。　The　downside　is　that　the　administrator　needs　to　　

　　　　　　　　　　understand　what　the　moving　parts　are。　　

　　　　　　　　　　　　　　　　People　have　a　tendency　to　make　everything　configurable　and　leave　nothing　to　the　puter　　

　　　　　　　　　　program。　Whether　or　not　something　works　depends　on　how　the　configuration　is　written。　In　　

　　　　　　　　　　　a　convention　architecture；　the　called　functionality　will　make　decisions　about　what　it　deems　　

　　　　　　　　　　　appropriate。　

　　　　　　　　　　　　　　　　Here　is　an　example　of　configuration：　



　　　　　　　　　　　　　　　_　

　　　　　　　　　　　　　　Public　Property　TypeName（）　As　String　

　　　　　　　　　　　　　　　　　　Get　　

　　　　　　　　　　　　　　　　　　　　　　Return　CStr（MyBase。Item（_propTypeName））　

　　　　　　　　　　　　　　　　　　End　Get　

　　　　　　　　　　　　　　End　Property　



　　　　　　　　　　　　　　　　The　code　should　look　familiar；　as　it　reassembles　the　configuration　code　you　saw　earlier。　　

　　　　　　　　　　But　this　code　is　overconstrained　and　requires　too　many　moving　parts。　It　would　be　great　to　　

　　　　　　　　　　　simplify　it　to　the　following　code　（which　does　not　pile　because　you　cannot　change　the　code　　

　　　　　　　　　　base　of　the　　library）。　



　　　　　　　　　　　　　　　_　

　　　　　　　　　　　　　　Public　ReadOnly　Property　TypeName（）　As　String　

　　　　　　　　　　　　　　　　　　Get　　

　　　　　　　　　　　　　　　　　　　　　　Return　CStr（MyBase。Item（_propTypeName））　

　　　　　　　　　　　　　　　　　　End　Get　

　　　　　　　　　　　　　　End　Property　



　　　　　　　　　　　　　　　　The　difference　between　the　two　code　pieces　is　the　missing　parameters　in　the　　attributes。　　

　　　　　　　　　　The　parameters　are　not　necessary　because　they　are　already　defined　by　the　data　member　　

　　　　　　　　　　_propTypeName；　and　you　can　use　the　identifier　of　the　property　as　that　extra　piece　of　informa

　　　　　　　　　　tion。　So　the　property　identifier　TypeName　could　be　used　as　an　identifier　for　an　XML　attribute。　

　　　　　　　　　　　　　　　　Some　may　argue　that　by　having　a　cross…reference　between　the　property　identifier　and　　

　　　　　　　　　　　configuration　identifier；　you　are　creating　a　hard…coded　dependency。　That’s　a　valid　argument。　　

　　　　　　　　　　But　is　the　code’s　assumption　a　mon…sense　assumption？　Is　it　an　extreme　proposition　to　say　　

　　　　　　　　　　that　your　property　identifier　is　the　name　of　your　XML　attribute？　The　answer　is　that　it　is　not　an　　

　　　　　　　　　　　extreme　proposition；　and　the　Ruby　on　Rails　creators　said　the　same　when　creating　their　own　　

　　　　　　　　　　　architecture。　

　　　　　　　　　　　　　　　　Let’s　now　consider　the　ability　to　indicate　whether　a　configuration　item　is　required。　By　　

　　　　　　　　　　　specifying　whether　or　not　an　attribute　is　required；　you　can　avoid　an　exception　at　a　later　point。　　

　　　　　　　　　　However；　think　about　the　bigger　context。　The　　IsRequired　attribute　is　processed　when　the　　

　　　　　　　　　　program　is　started。　The　validity　of　the　configuration　file　is　not　processed　at　pile　time；　and　　

　　　　　　　　　　thus　the　only　thing　that　IsRequired　does　is　generate　an　exception　earlier。　Maybe　you　want　to　　

　　　　　　　　　　　avoid　any　runtime　errors　that　could　bring　down　a　program　during　processing。　I　don’t　think　it　is　　


…………………………………………………………Page　361……………………………………………………………

　　　　　　　　　　CH　AP　T　E　R　　　1　2　　　■　　　　L　E　AR　N　IN　G　　　AB　O　U　T　　　AP　P　L　I　CAT　I　ON　　　CO　N　F　IG　U　R　AT　IO　N　　　A　N　D　　　D　Y　N　A　M　IC　　　L　O　AD　IN　G　339　



a　big　advantage；　but　I　am　sure　others　will　think　it　is；　and　thus　using　the　IsRequired　property　　

is　a　judgment　call。　　



■Note　　The　aim　of　convention…based　architecture　is　to　make　as　many　assumptions　as　possible；　without　　

sacrificing　the　bigger　goal　of　the　application。　A　good　convention…based　architecture　is　not　easy　to　create　　

because　it　requires　pletely　understanding　the　needs　of　the　developers　and　those　who　run　the　application。　　

My　personal　rule　of　thumb　is　to　solve　the　problem　first；　and　then　decide　what　should　be　configured　and　what　　

should　be　a　convention。　



Dynamically　Loading　Base　Class　or　　

Interface　Types　



This　chapter　demonstrated　two　categories　of　code　that　were　dynamically　loaded。　The　first　cate

gory　was　a　type　that　implemented　an　interface　（Implementation　and　IDefinition）。　The　second　　

type　was　a　class　that　subclassed　another　class　（　LoaderSection；　ConfigurationSection）。　Each　　

approach　has　its　advantages　and　disadvantages；　but　there　is　a　single　rule　that　you　can　use。　

　　　　　Whether　to　use　an　interface　or　class　depends　on　how　much　responsibility　you　want　to　　

delegate　to　the　implementation。　In　the　configuration　processing　example；　the　　infrastructure　　

specifically　indicated　that　the　only　responsibility　of　the　dynamically　loaded　class　is　to　indicate　　

which　identifiers　should　be　processed。　How　the　value　of　the　identifiers　are　extracted　and　converted　　

into　　types　is　the　responsibility　of　the　base　class。　

　　　　　When　you　instantiate　a　type　and　use　an　interface；　you　are　delegating　plete　control　to　　

the　dynamically　instantiated　type。　The　calling　code　is　explicitly　saying；　“Here　is　your　contract。　　

How　you　deal　with　it　is　your　responsibility。　Just　make　sure　to　implement　the　contract　properly。”　　

By　delegating　all　the　responsibility；　you　are；　in　a　sense；　asking　for　trouble；　because　developers　　

might　implement　a　contract　incorrectly。　



The　Important　Stuff　to　Remember　



In　this　chapter；　you　learned　about　configuring　an　application　and　dynamically　loading　code　　

that　is　executed。　The　main　items　to　remember　are　as　follows：　



　　　　　o　　A　　application　configuration　file　works　only　because　there　is　code　in　the　application　　

　　　　　　　　that　uses　the　specified　items　in　the　configuration　file。　　



　　　　　o　　Applications　have　　application　configuration　files　where　the　name　of　the　file　is　the　　

　　　　　　　　name　of　the　executing　application　appended　with　a　　。config。　



　　　　　o　　A　　application　configuration　file　is　a　specially　formatted　XML　file。　



　　　　　o　　A　　application　configuration　file　applies　to　a　specific　assembly　loaded　by　the　　

　　　　　　　　application。　



　　　　　o　　The　default　scenario　for　a　　application　configuration　file　is　to　store　the　settings　as　　

　　　　　　　　key/value　pairs　in　the　　section。　


…………………………………………………………Page　362……………………………………………………………

340　　　　　　　CH　AP　T　E　R　　　1　2　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　A　PP　L　I　CA　TI　O　N　　　CO　N　F　I　G　U　R　AT　IO　N　　　AN　D　　　D　Y　N　A　M　I　C　　L　O　AD　I　N　G　



　　　　　　　　　　　　　　　o　　You　can　enhance　the　　application　configuration　file；　but　that　implies　implementing　　

　　　　　　　　　　　　　　　　　　types　that　specifically　outline　which　XML　nodes　and　attributes　are　to　be　present　in　the　XML。　



　　　　　　　　　　　　　　　o　　When　processing　data；　you　sometimes　need　a　type　（such　as　ConfigurationInfo）　that　is　　

　　　　　　　　　　　　　　　　　　used　to　store　information　in　a　structured　manner　for　a　specific　reason。　　



　　　　　　　　　　　　　　　o　　　has　plenty　of　functionality　that　allows　a　developer　to　dynamically　execute　code。　



　　　　　　　　　　　　　　　o　　One　way　of　dynamically　executing　code　is　to　load　an　assembly；　instantiate　a　type；　and　　

　　　　　　　　　　　　　　　　　　then　cast　the　instance　to　a　specific　known　type。　



　　　　　　　　　　　　　　　o　　You　can　instantiate　private　types　declared　in　an　assembly。　



　　　　　　　　　　　　　　　o　　You　can　use　the　GAC　to　store　assemblies　that　will　be　shared　by　multiple　applications。　



　　　　　　　　　　　　　　　o　　Use　the　GAC　only　if　you　must。　If　you　do　use　the　GAC；　you　need　to　create　strongly　named　　

　　　　　　　　　　　　　　　　　　assemblies　using　signing。　



　　　　　　　　　　　　　　　o　　Regardless　of　how　an　assembly　is　versioned；　a　version　number　should　exist　and　be　used。　



　　　　　　　　　　　　　　　o　　In　convention…based　coding；　your　code　makes　assumptions　about　its　behavior。　　

　　　　　　　　　　　　　　　　　　Convention…based　coding　is　more　pact；　but　because　assumptions　are　made；　the　　

　　　　　　　　　　　　　　　　　　code　is　less　flexible。　However；　do　not　confuse　flexibility　with　being　the　best　way　to　do　　

　　　　　　　　　　　　　　　　　　something。　You　should　have　flexible　code　when　you　need　it；　not　just　because　it　can　be　　

　　　　　　　　　　　　　　　　　　written　that　way。　



　　　　　　　　　　　Some　Things　for　You　to　Do　



　　　　　　　　　　　The　following　are　some　exercises　for　you　to　do　to　apply　what　you’ve　learned　in　this　chapter。　



　　　　　　　　　　　　　　　　1。　　Rewrite　the　configuration　code　so　that　the　configuration　file　specifies　a　directory　where　　

　　　　　　　　　　　　　　　　　　　　all　assemblies　in　that　directory　are　loaded。　　



　　　　　　　　　　　　　　　　2。　　Having　read　all　of　the　assemblies　with　the　rewritten　configuration；　call　a　predefined　　

　　　　　　　　　　　　　　　　　　　　type　that　will　tell　the　caller　which　types　are　available　and　their　appropriate　types。　



　　　　　　　　　　　　　　　　3。　　Modify　ConfigurationLoader　so　that　it　uses　the　new　configuration　architecture　to　　

　　　　　　　　　　　　　　　　　　　　instantiate　types。　


…………………………………………………………Page　363……………………………………………………………

C　　H　　A　　P　　T　　E　　R　　　　　1　　3　



■　■　■　



Learning　About　Multithreading　



Your　brain　allows　you　to　multitask。　For　example；　you　can　prepare　dinner　while　talking　on　the　　

telephone。　However；　this　multitasking　has　limits；　and　you　can　do　only　two　or　three　things　　

simultaneously。　But　suppose　you　could　put　down　the　work；　start　another　piece　of　work；　then　　

put　that　down；　and　then　switch　to　the　original　work。　How　many　tasks　could　you　handle　at　the　　

same　time？　Probably　a　few　hundred；　because　what　you　are　doing　is　serializing　the　multitasking。　　

　　　　　Now　suppose　you　and　another　person　are　preparing　dinner　in　the　kitchen；　but　you　are　not　　

municating　with　each　other。　What　is　the　likelihood　that　you　will　run　into　the　other　person？　　

Probably　pretty　high。　What　I　am　trying　to　get　across　here　is　the　difference　between　multitasking　　

with　a　single　brain　and　multitasking　with　multiple　brains。　Multitasking　always　has　a　cost；　which　is　　

orchestration。　And　sometimes　doing　more　multitasking　is　not　going　to　speed　things　up。　There　　

is　a　limit　to　how　many　brains　are　required　to　run　an　efficient　kitchen。　

　　　　　The　focus　of　this　chapter　is　how　to　write　code　that　is　capable　of　multitasking。　The　operating　　

system　multitasks；　by　default；　but　whether　or　not　your　program　multitasks　depends　on　how　　

you　write　your　code。　For　example；　suppose　the　lighting　controller　introduced　in　Chapter　8　had　　

to　control　3；000　rooms？　To　be　able　to　process　such　a　large　number　of　rooms；　you　would　use　the　　

same　code；　except　run　it　in　parallel。　And　therein　lies　the　problem　of　code　that　needs　to　multitask。　　

It’s　more　difficult　to　make　code　run　efficiently　in　parallel。　A　mon　problem　in　multitasking　　

applications　is　the　dreaded　deadlock。　A　deadlock　occurs　when　two　tasks　need　data　from　each　　

other　to　continue；　which　means　neither　can　continue。　

　　　　　Running　code　in　parallel　requires　coding　discipline；　as　you　will　learn　in　this　chapter。　We　　

will　use　only　a　single　project；　named　JugglingTasks；　which　is　a　console　application　that　imple

ments　the　techniques　demonstrated　in　this　chapter。　



Understanding　Multitasking　



One　of　the　biggest　jumps　in　puting　history　was　when　the　puter　went　from　a　machine　　

that　carried　out　a　single　task　to　a　multitasking　machine。　The　old　modore　64　and　VIC…20　　

were　single…tasking　machines。　You　started　the　puter；　and　then　the　puter　waited　for　　

you　to　do　something。　If　you　decided　to　make　the　puter　run　a　loop　saying　“hello”　millions　　

of　times；　that　is　all　the　puter　would　do。　The　puter　could　not　do　one　thing　and　then　do　　

something　else　while　waiting　for　an　answer　from　the　executing　task。　How　could　anyone　get　　

anything　done？　（On　the　other　hand；　you　could　argue　that　people　might　be　more　productive　if　　

they　could　work　in　only　a　single　program；　and　not　also　check　their　e…mail；　look　at　the　latest　blog　　

entry　from　their　favorite　author；　and　so　on。）　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　341　


…………………………………………………………Page　364……………………………………………………………

342　　　　　　　CH　AP　T　E　R　　　1　3　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　M　U　L　T　I　TH　R　E　A　DI　N　G　



　　　　　　　　　　　　　　　　Things　changed　quite　dramatically　when　puters　could　multitask。　Server　puters　　

　　　　　　　　　　　running　operating　systems　like　Unix　were　multitasking　from　day　one。　Operating　systems　like　　

　　　　　　　　　　Windows　were　not　100％　preemptive　multitasking　until　Windows　NT　and　Windows　95。　Notice　　

　　　　　　　　　　　that　I　used　the　term　preemptive；　which　makes　a　big　difference。　　

　　　　　　　　　　　　　　　　Plain…vanilla　multitasking　is　multitasking　where　individual　tasks　cooperate　and　allocate　　

　　　　　　　　　　　resources　as　a　collective。　It　is　essentially　a　dead…end　idea；　and　the　best　example　of　how　it　worked　is　　

　　　　　　　　　　Windows　3。0　and　Windows　3。1　（but　these　were　full　of　hacks）。　Now　let’s　see　what　preemptive　　

　　　　　　　　　　　multitasking　means。　



　　　　　　　　　　　Preemptive　Multitasking　



　　　　　　　　　　　Preemptive　multitasking　is　when　the　operating　system　controls　which　application　does　what　　

　　　　　　　　　　　and　when。　Realize　that　you　can　run　an　application　because　applications　are　treated　as　po

　　　　　　　　　　　nents。　You　don’t　believe　me？　Create　a　console　application　and　rename　the　method　Main（）　to　　

　　　　　　　　　　　Mains（）。　See　what　happens。　The　reality　is　that　the　Main（）　method；　as　it　is　declared；　is　an　API　　

　　　　　　　　　　　used　by　the　operating　system　t