友情提示：如果本网页打开太慢或显示不完整，请尝试鼠标右键“刷新”本网页！
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
快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部!
温馨提示： 温看小说的同时发表评论，说出自己的看法和其它小伙伴们分享也不错哦！发表书评还可以获得积分和经验奖励，认真写原创书评 被采纳为精评可以获得大量金币、积分和经验奖励哦！