按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
objects。Add（New Another（））
For Each obj As Example In objects
Console。WriteLine（〃Object value （〃 & obj。Value & 〃）〃）
Next
The bolded code illustrates how the collection object contains two instances of Example
and one instance of Another。 The code will pile； which misleads you into believing every
thing is fine。 If you try to run the application （either normally or in debug mode）； you will see
something similar to the following：
Unable to cast object of type 'OneToManySamples。Another' to type
'OneToManySamples。Example'。
So； should a collection contain multiple types？ There are arguments for and against the
idea； but the problem is not the ability to mix types。 The problem is that you can mix types；
even if you don’t really intend to do that。
Using the For Each statement with mixed types will result in an exception； because for
each iteration； the object in the collection is cast to a type Example。 As the last item in the collec
tion is of type Another； the cast will fail； and an exception will be generated。 Collections before
2。0 could not enforce type consistency； and that was a problem。
Had you desired to mix types； the proper For Each loop would have been as follows：
Dim objects As IList = new ArrayList（）
objects。Add（New Example With ｛。Value = 10｝）
objects。Add（New Example With ｛。Value = 20｝）
objects。Add（New Another（））
For Each obj As Object In objects
If TypeOf （obj） Is Example Then
Dim example As Example = CType（obj； Example）
Console。WriteLine（〃Object value （〃 & example。Value & 〃）〃）
ElseIf TypeOf （obj） Is Another Then
Console。WriteLine（〃This is another object〃）
End If
Next
…………………………………………………………Page 255……………………………………………………………
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 233
The Problem of Value Types
Another issue with pre…Visual Basic 2005 collections is that they have performance problems。
Consider the following code that manipulates value types。
Dim objects As IList = New ArrayList（）
objects。Add（1）
objects。Add（2）
For Each val as Integer in objects
Console。WriteLine（〃Value （〃 & val & 〃）〃）
Next
In the example； an ArrayList is again instantiated； but this time； the numbers 1 and 2 are
added to the collection。 Then； in the For Each statement； the integers are iterated。 The code
works； but there is a hidden performance hit。 The items added to the collection are value types；
which means you are manipulating stack…based memory。
However； the definition of IList uses objects：
Public Interface IIList
Inherits ICollection； IEnumerable
' Methods
Function Add（ByVal value As Object） As Integer
Sub Clear（）
Function Contains（ByVal value As Object） As Boolean
Function IndexOf（ByVal value As Object） As Integer
Sub Insert（ByVal index As Integer； ByVal value As Object）
Sub Remove（ByVal value As Object）
Sub RemoveAt（ByVal index As Integer）
' Properties
ReadOnly Property IsFixedSize（） As Boolean
ReadOnly Property IsReadOnly（） As Boolean
Property Item（ByVal index As Integer） As Object
End Interface
How IList is defined and how a value type is defined should raise alarms。 An object is a
reference type； and thus you have a conflict： IList stores reference types； but Integer is a value
type。
What’s happening is that the environment knows that there is a conflict and adds a
fix。 Don’t think of the fix as a hack； but as a way of solving a problem that all virtual machine
environments like need to address。 The environment uses the terms boxing and
unboxing to denote converting a value type into a reference type and then back again； respectively。
To understand boxing and unboxing； let’s consider the context。 You are creating a list that
references value types。 The array is a reference type that is stored on the heap； but value types are
stored on the stack。 If you get the array to reference data on the stack； you will have a consistency
issue； since the stack changes。 Thus； you will need to move the memory from the stack to the
heap； but that would violate the principle behind value types。 The solution is the promise
of boxing and unboxing。
…………………………………………………………Page 256……………………………………………………………
234 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
To illustrate what boxing does； I have written some code that is similar to the boxing of a
value type。 The difference is that my code is explicit and boxing is done automatically。
Class ReferenceHeap
Public Value As Integer
End Class
。 。 。
Public Sub Method（）
Dim onStack As Integer = 1
Dim onHeap As ReferenceHeap = New ReferenceHeap（） With ｛ 。Value = onStack ｝
End Sub
In the example； Method（） declares a value…type variable named onStack； which is allocated
in the context of a method and is thus on the stack。 The type ReferenceHeap is a class； and thus
a reference type； and automatically all of its data is stored on the heap。 When the variable
onHeap is allocated and initialized； the value from onStack is copied to the heap and