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

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





　　　　　　　　　　　　　　　o　You　can　subclass　only　a　single　class。　



　　　　　　　　　　　　　　　o　You　can　subclass　as　many　interfaces　as　desired；　but　they　must　be　declared　after　the　class。　


…………………………………………………………Page　447……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　425　



Using　the　New　Constraint　



The　purpose　of　the　New　constraint　is　to　limit　the　data　type　to　one　that　has　a　default　constructor；　　

as　in　this　example：　



Class　Example（Of　DataType　As　｛New｝）　　

　　　　Private　_value　As　DataType　



　　　　Public　Sub　New（）　

　　　　　　　　_value　=　New　DataType（）　

　　　　End　Sub　

End　Class　



　　　　　Without　the　　New　constraint；　the　bolded　code　cannot　be　piled。　　

　　　　　The　constructor　that　is　defined　with　the　New　constraint　does　not　take　parameters；　and　it　　

would　seem　that　this　is　a　bother。　After　all；　you　might　want　to　instantiate　the　type　with　some　　

state。　What　you　can　do　is　constrain　DataType；　and　then　instantiate　the　type　using　object　initial

izers。　For　example；　the　following　is　an　interface　that　has　a　single　property。　



Interface　IBase　　

　　　　Property　Value（）　As　Integer　

End　Interface　



　　　　　bining　the　IBase　interface　and　the　　New　keyword　as　constraints；　you　could　write　the　　

following　code。　



Class　Example（Of　DataType　As　｛IBase；　New｝）　　

　　　　Private　_value　As　DataType　



　　　　Public　Sub　New（）　

　　　　　　　　_value　=　New　DataType（）　With　｛。Value　=　10｝　

　　　　End　Sub　

End　Class　



　　　　　In　the　modified　example；　the　bolded　code　instantiates　DataType；　and　then　using　the　　

constraints；　the　object　initializer　that　defines　_value　is　possible。　



Using　the　Class　Constraint　



The　main　purpose　of　the　Class　constraint　is　to　indicate　whether　the　　generics　type　is　a　value　　

type　or　a　reference　type。　Here　is　an　example　of　a　type　that　wants　to　manage　only　reference　types：　



Class　AssumeReferenceType（Of　DataType　As　｛Class｝）　

　　　　Private　_value　As　DataType　



　　　　Public　Sub　New（ByVal　value　As　DataType）　　

　　　　End　Sub　

End　Class　


…………………………………………………………Page　448……………………………………………………………

426　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　　　　　　　If　you　were　to　declare　the　AssumeReferenceType　using　an　Integer；　as　shown　in　the　following　　

　　　　　　　　　　example；　the　code　would　not　pile。　



　　　　　　　　　　Dim　cls　As　AssumeReferenceType（Of　Integer）　=　_　

　　　　　　　　　　　　New　AssumeReferenceType（Of　Integer）（Nothing）　



　　　　　　　　　　　Nullable　Types　



　　　　　　　　　　In　；　Nothing　means　no　value；　and　we　all　understand　what　it　represents；　right？　For　example；　　

　　　　　　　　　　the　following　code　shows　how　to　use　Nothing。　



　　　　　　　　　　Dim　value　As　Object　=　Nothing　

　　　　　　　　　　　　

　　　　　　　　　　　If　value　Is　Nothing　Then　

　　　　　　　　　　　　　　Console。WriteLine（〃Yup　a　Nothing〃）　

　　　　　　　　　　　End　If　



　　　　　　　　　　　　　　　　The　example　is　obvious　and　does　nothing　useful。　If　you　attempted　to　call　the　Object。　

　　　　　　　　　　ToString（）　method　on　value；　an　exception　would　be　generated。　So；　what　the　code　has　created　　

　　　　　　　　　　is　a　variable　value　that　references　nothing　and　is　nothing。　This　works　because　the　example　uses　　

　　　　　　　　　　a　　reference　type。　Let’s　see　what　happens　when　you　assign　a　value　to　a　value　type　that　we　　

　　　　　　　　　　equate　to　no　real　value。　



　　　　　　　　　　Dim　value　As　Integer　=　0　

　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　If　value　=　0　Then　

　　　　　　　　　　　　　　Console。WriteLine（〃Yup　a　Nothing？？？〃）　

　　　　　　　　　　　End　If　



　　　　　　　　　　　　　　　　This　time；　value　is　not　of　the　type　Object；　but　is　of　the　type　Integer。　And　value　is　assigned　　

　　　　　　　　　　a　value　of　0　to　indicate　no　real　value。　Now　many　of　you　will　be　saying；　“Hey；　wait　a　minute—　

　　　　　　　　　　0　　Nothing。”　Yet；　in　the　programming　languages　C＋＋　and　C；　Nothing　and　0　have　the　same　　

　　　　　　　　　　contextual　meaning；　so　it’s　not　so　outlandish。　

　　　　　　　　　　　　　　　Visual　Basic　has　a　programming　construct　called　the　nullable　type。　The　nullable　type　solves　the　　

　　　　　　　　　　problem　of　knowing　whether　or　not　a　value　type　has　been　assigned。　This　is　needed　when　inter

　　　　　　　　　　acting　with　relational　databases。　For　example；　there　is　no　way　to　indicate　that　an　integer　value　　

　　　　　　　　　　is　not　assigned；　since　declaring　a　value　type　means　declaring　a　stack　variable；　and　it　will　have　a　　

　　　　　　　　　　default　value。　In　other　words；　there　is　no　chance　a　value　type　will　have　a　null　reference。　

　　　　　　　　　　　　　　　A　nullable　type　in　Visual　Basic　is　used　to　define　a　value…type　variable　that　might　have　a　null　　

　　　　　　　　　　state。　In　the　value　type　example；　the　integer　value　was　assigned　a　value　of　0；　but　a　value　of　　

　　　　　　　　　　Nothing　would　have　been　more　appropriate。　However；　value　types　cannot　be　assigned　a　value　　

　　　　　　　　　　of　Nothing；　they　must　be　assigned　some　valid　value。　　

　　　　　　　　　　　　　　　　To　further　demonstrate　the　restrictions　of　a　value　type；　the　following　is　a　Structure　　

　　　　　　　　　　declaration。　


…………………………………………………………Page　449……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　427　



Structure　ExampleStructure　　

　　　　Public　value　As　Integer　

End　Structure　



　　　　　Here’s　how　we　might　use　it：　



Dim　ex　As　ExampleStructure　=　Nothing　



　　　　　The　structure　ExampleStructure　is　defined　using　the　Structure　keyword；　which　means　that　　

ExampleStructure　is　a　value　type。　The　next　line；　where　the　variable　ex　is　assigned　a　value　of　　

Nothing；　will　result　in　an　action　where　nothing　happens　other　than　resetting　the　variable　ex　to　　

0。　And　as　was　illustrated　earlier；　0　is　not　　Nothing。　　

　　　　　The　inability　to　assign　Nothing　is　odd；　because　structures　behave　similarly　to　reference　　

types　in　many　ways。　Instantiating　a　default　value　of　a　structure　is　not　always　the　right　answer；　　

since　the　data　members　might　not　have　a　default　value。　

　　　　　The　nullable　type　makes　it　possible　for　value　types　（for　example；　structures）　to　be　nothing。　　

In　Visual　Basic；　you　define　a　nullable　type　by　using　the　　generics　class　Nullable　or　the　　

nullable　type　notation；　as　follows：　



Dim　ex　As　Nullable（Of　ExampleStructure）　=　Nothing　



or　



Dim　ex　As　ExampleStructure？　=　Nothing　



　　　　　Using　nullable　types；　it　is　possible　to　assign　a　Nothing　value　to　a　value　type。　To　assign　a　　

value　to　a　nullable　type；　you　need　to　explicitly　assign　the　variable；　as　in　the　following　example。　



ex　=　New　ExampleStructure（）　With　｛。value　=　10｝　



　　　　　And　then　to　reference　the　structure—in　particular；　the　property　value—use　the　following　　

code。　



Console。WriteLine（〃（〃　&　ex。Value。value　&　〃）〃）　　　



　　　　　The　additional　reference　of　Value　is　the　link　between　the　reference　type　Nullable　and　the　　

value　type　　ExampleStructure。　



■Note　　Nullable　types　are　not　intended　to　be　used　in　conjunction　with　reference　types。　If　you　attempt　to　use　　

a　nullable　type　with　a　reference　type；　you　will　get　a　Visual　Basic　piler　error。　Nullable　types　are　designed　　

for　use　by　value　types；　and　there　is　no　other　mystical　or　magical　reason　to　use　a　nullable　type。　



Partial　Classes　and　Methods　



By　default；　whenever　you　create　a　type；　you　must　declare　the　plete　type　in　one　file　and　as　　

one　entity。　For　example；　the　following　class　would　need　to　be　declared　in　the　context　of　a　single　file。　


…………………………………………………………Page　450……………………………………………………………

428　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　　　　　Class　Example　　

　　　　　　　　　　　　　　　　　　Const　BaseValue　as　Integer　=　10　

　　　　　　　　　　　　　　　　　　Public　Sub　AddNumbers（ByVal　value1　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByVal　value2　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByRef　response　As　Integer）　　

　　　　　　　　　　　　　　　　　　　　　　response　=　BaseValue　＋　value1　＋　value2　

　　　　　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　The　Example　class　has　a　single　method　AddNumbers；　and　the　method　implementation　adds　　

　　　　　　　　　　two　numbers　to　a　base　value　（BaseValue）。　Everything　is　in　a　single　file。　But　suppose　you　wanted　　

　　　　　　　　　　to　automatically　generate　Example；　and　have　it　generate　the　data　member　BaseValue；　but　not　　

　　　　　　　　　　the　method　AddNumbers。　To　do　that；　you　would　need　to　split　the　class　into　two　separate　classes；　　

　　　　　　　　　　where　one　class　subclasses　the　other：　



　　　　　　　　　　　　　　Class　BaseGenerated　　

　　　　　　　　　　　　　　　　　　Protected　Const　BaseValue　As　Integer　=　10　

　　　　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　Class　Example　：　Inherits　BaseGenerated　　

　　　　　　　　　　　　　　　　　　Public　Sub　AddNumbers（ByVal　value1　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByVal　value2　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByRef　response　As　Integer）　　

　　　　　　　　　　　　　　　　　　　　　　response　=　BaseValue　＋　value1　＋　value2　

　　　　　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　Having　one　class　subclass　the　other　is　fine；　and　it　works。　The　class　BaseGenerated　could　be　　

　　　　　　　　　　stored　in　one　file；　and　Example　could　be　stored　in　another　file。　But　that　approach　can　be　a　bit　　

　　　　　　　　　　problematic；　as　it　implies　a　specific　architecture　where　one　class　subclasses　the　other。　Another　　

　　　　　　　　　　approach　would　be　to　use　the　Partial　keyword　in　the　context　of　a　class；　as　follows：　



　　　　　　　　　　　　　　Class　Example　　

　　　　　　　　　　　　　　　　　　Const　BaseValue　As　Integer　=　10　

　　　　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　Partial　Class　Example　　

　　　　　　　　　　　　　　　　　　Public　Sub　AddNumbers（ByVal　value1　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByVal　value2　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByRef　response　As　Integer）　　

　　　　　　　　　　　　　　　　　　　　　　response　=　BaseValue　＋　value1　＋　value2　

　　　　　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　　　　　End　Class　



　　　　　　　　　　　　　　　When　you　use　the　　Partial　keyword；　you　are　defining　a　partial　class。　The　plete　class　is　　

　　　　　　　　　　the　sum　of　all　the　separate　partial　class　definitions　for　the　class　（which　could；　and　typically　　

　　　　　　　　　　would；　reside　in　separate　files）。　Thus；　one　part　of　the　class　could　be　autogenerated；　and　the　　

　　　　　　　　　　other　piece　could　be　hand…coded。　　


…………………………………………………………Page　451……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　T　E　C　HN　IQ　U　E　S　429　



　　　　　A　requirement　of　partial　classes　is　that　they　must　be　wholly　defined　in　an　assembly。　The　　

partial　class　is　of　relevance　only　to　the　Visual　Basic　piler；　and　not　to　the　　language。　

　　　　　Another　usage　of　the　　Partial　keyword　is　to　have　methods　that　are　defined　in　one　place　but　　

implemented　in　another。　Think　of　partial　methods　as　defining　an　abstract　class　method　and　　

implementing　it　within　the　same　class。　The　following　is　an　example　of　using　a　partial　method。　



Class　Example　

　　　　Partial　Private　Sub　AddNumbers（ByVal　value1　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByVal　value2　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ByRef　response　As　Integer）　

　　　　End　Sub　



　　　　Public　Sub　Method（）　

　　　　　　　　Dim　response　As　Integer　=　0　



　　　　　　　　AddNumbers（1；　2；　response）　

　　　　　　　　Console。WriteLine（〃Added　numbers　（〃　&　response　&　〃）〃）　

　　　　End　Sub　

End　Class　



Partial　Class　Example　

　　　　Private　Sub　AddNumbers（ByVal　value1　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　ByVal　value2　As　Integer；　_　

　　　　　　　　　　　　　　　　　　　　　　　　　　　ByRef　response　As　Integer）　

　　　　　　　　response　=　value1　＋　value2　

　　　　End　Sub　

End　Class　



　　　　　Partial　methods　are　defined　in　the　context　of　a　partial　class。　In　one　part　of　your　class；　you　　

would　prefix　the　identifier　　Partial　to　the　method　and　declare　it。　In　the　other　part　of　the　class；　　

you　would　implement　the　method。　

　　　　　Partial　methods；　like　partial　classes；　have　some　restrictions：　



　　　　　o　They　must　be　declared　as　a　Sub。　



　　　　　o　They　must　be　declared　to　be　Private。　



　　　　　o　The　methods　can　be　shared　and　use　extension　methods。　



　　　　　Overall；　partial　methods　and　classes　should　not　be　used　as　a　general　programming　practice；　　

because　they　are　intended　to　be　employed　in　the　context　of　autogenerated　code　（such　as　　

Form1。vb　in　Windows　forms）。　When　used　in　that　context；　partial　methods　and　classes　are　an　　

excellent　solution。　

　　　　　Partial　methods　are　also　useful　substitutes　for　conditional　pilation　constants；　because　　

if　you　don’t　implement　a　partial　method；　any　mention　of　it　is　removed　from　the　piled　class。　　

This　means；　for　example；　that　you　can　wrap　the　implementation　with　a　single　#If；　rather　than　　

littering　many　instances　of　#If　in　your　code。　Here’s　an　example：　


…………………………………………………………Page　452……………………………………………………………

430　　　　　　　CH　AP　T　E　R　　　1　6　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　O　TH　E　R　　　V　IS　U　AL　　　B　A　SI　C　　TE　C　H　N　IQ　U　E　S　



　　　　　　　　　　　　　　Partial　Private　Sub　Display（ByVal　message　As　String）　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　#If　DEBUG　Then　

　　　　　　　　　　　　　　Private　Sub　Display（ByVal　message　As　String）　

　　　　　　　　　　　　　　　　　　Console。WriteLine（message）　

　　　　　　　　　　　　　　End　Sub　

　　　　　　　　　　#End　If　



　　　　　　　　　　　　　　Sub　RunAll（）　

　　　　　　　　　　　　　　　　　　RunFirst（）　

　　　　　　　　　　　　　　　　　　Display（〃Done　RunFirst（）〃）　

　　　　　　　　　　　　　　　　　　RunSecond（）　

　　　　　　　　　　　　　　　　　　Display（〃Done　RunSecond（）〃）　

　　　　　　　　　　　　　　　　　　RunThird（）　

　　　　　　　　　　　　　　　　　　Display（〃Done　RunThird（）〃）　

　　　　　　　　　　　　　　End　Sub　



　　　　　　　　　　The　Important　Stuff　to　Remember　



　　　　　　　　　　In　this　chapter；　you　learned　about　some　Visual　Basic　techniques　that　are　useful　in　specific　situ

　　　　　　　　　　ations。　Here　are　the　points　you　should　keep　in　mind：　



　　　　　　　　　　　　　　　o　　You　will　need　to　use　the　arithmetic　operators。　Some　are　obvious；　others　are　not。　Take　the　　

　　　　　　　　　　　　　　　　　　time　to　get　used　to　coding　with　them。　　



　　　　　　　　　　　　　　　o　　Overloading　operators　makes　sense　when　you　need　to　define　custom　types　and　you　　

　　　　　　　　　　　　　　　　　　want　them　to　support　basic　operators　such　as　add；　subtract；　and　so　on。　When　imple

　　　　　　　　　　　　　　　　　　menting　the　operators；　be　careful　to　do　a　logically　correct　implementation。　



　　　　　　　　　　　　　　　o　　To　be　able　to　use　methods　or　properties　on　　generics　parameters；　they　need　to　be　　

　　　　　　　　　　　　　　　　　　constrained。　Constraints　are　an　effective　way　of　indicating　basic　functionality　possessed　　

　　　　　　　　　　　　　　　　　　by　　generics　types。　Even　though　you　could　usually　achieve　the　same　results　using　　

　　　　　　　　　　　　　　　　　　interfaces；　that　approach　is　not　as　elegant。　



　　　　　　　　　　　　　　　o　　Visual　Basic　has　the　GoTo　keyword；　even　though　some　consider　the　use　of　GoTo　as　poor　　

　　　　　　　　　　　　　　　　　　programming。　Visual　Basic　has　ensured　that　you　can’t　easily　shoot　yourself　in　the　foot。　



　　　　　　　　　　　　　　　o　　The　nullable　type　is　used　to　indicate　whether　or　not　a　value　type　has　been　assigned。　You　　

　　　　　　　　　　　　　　　　　　will　use　this　type　when　interacting　with　a