(接上篇)
正如你所见,泛型使用起来很简单。强类型化的代码可以避免运行时错误;智能感知会工作得更好。虽然使用泛型已经有非常充分的理由,不过使用泛型还有更多的优点:性能和代码重用。
将泛型技术引入 .Net 框架的一个主要原因是为了提高性能。比如集合类可以比以前工作得更快,因为编译器能够针对集合所储存的类型进行优化。下面的代码比较了数组、 ArrayList 以及泛型 List 的性能:
txtOutput.Text = "Performance" & vbCrLf
Const iterations As Integer = 5000000
PerfTime.Start()
Dim myArray(iterations) As Integer
For i As Integer = 0 To iterations - 1
myArray(i) = i
Next
Dim elapsed As Integer = PerfTime.Stop
txtOutput.Text &= "Array time: " & elapsed & vbCrLf
myArray = Nothing
GC.Collect()
PerfTime.Start()
Dim myArrayList As New ArrayList
For i As Integer = 0 To iterations - 1
myArrayList.Add(i)
Next
elapsed = PerfTime.Stop
txtOutput.Text &= "ArrayList time: " & elapsed & vbCrLf
myArrayList = Nothing
GC.Collect()
PerfTime.Start()
Dim myList As New List(Of Integer)
For i As Integer = 0 To iterations - 1
myList.Add(i)
Next
elapsed = PerfTime.Stop
txtOutput.Text &= "List time: " & elapsed & vbCrLf
myList = Nothing
GC.Collect()
这段代码在固定长度的数组中储存了 500 万个数值,同时也在自动增长的 ArrayList 和泛型 List 中储存同样多的数值,性能数值看起来非常有趣:
Array 时间 : 344
ArrayList 时间 : 4656
List 时间 : 797
有特定类型的定长数组有无与伦比的速度,而且不需要为改变大小付出代价。而集合类型的大小都是自动增长,如果有固定数组 1/2 的性能是相当不错的。接下来看看 ArrayList ,非常不幸,只有固定数据 1/10 的性能。问题出在 ArrayList 被设计成储存引用型变量, Integer 是值类型,在储存到 ArrayList 以前要经过 “ 装箱 ” 操作,将 Integer 转为 Object 型。装箱的代价是非常昂贵的,所以当你储存值类型数据(如 Integer 、 Date 、 Boolean 以及你自己创建的 Structure 等)时,使用泛型将获得非常可观的性能提升。
更多关于 “ 装箱 ” 和 “ 拆箱 ” 操作的信息,请参见 MSDN 库中的 “ 装箱转换 ” 和 “ 拆箱转换 ”
** 创建泛型类型和方法 ** ** **
并不是只能使用 Visual Basic.Net 提供的泛型类型,你可以创建你自己的泛型类型和方法。
** 泛型方法 ** ** **
当你想实现一些不与特定类型相关的一般算法时,你可能想创建泛型方法。举个例子,典型的冒泡排序需要遍历数组中的所有项目,两两比较,并交换需要排序的数值。
如果你已经确定只要进行整数的排序,你可以简单地编写一个只能用于 Integer 类型的 Swap 方法。但是如果你想能够排序任何类型,你就可以编写一个泛型 Swap 方法如下:
Private Sub Swap(Of ItemType ) _
(ByRef v1 As ItemType , ByRef v2 As ItemType )
Dim temp As _ ItemType _
temp = v1
v1 = v2
v2 = temp
End Sub
注意 “Of ItemType” ,当 Swap 方法被调用时,除了必须提供所需的参数,还必须传入一个数据类型。这个数据类型会代替任何实例中的 ItemType 。下面的例子调用了 Swap :
Swap(Of Integer)(v1, v2)
这条语句告诉 Swap 方法它将交换的是 Integer 类型。如果你回过头去看看 Swap 的代码,这条语句的意思就是让 JIT 将所有的 ItemType 换成 Integer ,这个 Swap 方法实际上已经被 JIT 重写成:
Private Sub Swap(ByRef v1 As Integer , ByRef v2 As Integer )
Dim temp As _ Integer _
temp = v1
v1 = v2
v2 = temp
End Sub
这是实际执行的代码, JIT 生成一个专用于 Integer 类型的方法。如果你接下来想要排序字符串类型,你就可以用另一 Swap 的调用如下:
Swap(Of String)(v1, v2)
当方法执行的时候, JIT 会生成另一个版本的 Swap ,这次是特定成 String 类型的:
Private Sub Swap(ByRef v1 As String , ByRef v2 As String )
Dim temp As _ String _
temp = v1
v1 = v2
v2 = temp
End Sub
下面是一个使用泛型 Swap 的冒泡排序的完整例子:
Private Sub btnSortIntegers_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSortIntegers.Click
Dim ints(9) As Integer
Dim r As New Random
For i As Integer = 0 To 9
ints(i) = r.Next(1, 100)
Next
' 冒泡排序
For j As Integer = 0 To 9
For k As Integer = 9 To 1 Step -1
If ints(k) < ints(k - 1) Then
Swap(Of Integer)(ints(k), ints(k - 1))
End If
Next
Next
txtOutput.Text = "Sort Integers" & vbCrLf
For i As Integer = 0 To 9
txtOutput.Text &= ints(i) & vbCrLf
Next
End Sub
** 泛型类型 ** ** **
最后一点,你能够创建完全泛型的类型,使用这种 “Of ItemType” 方法创建类的声明如下:
Public Class SomeClass(Of ItemType)
Private internalVar as ItemType
Public Function SomeMethod(ByVal value As ItemType) As ItemType
End Function
End Class
这段代码对类的作用与方法是相同的。 JIT 编译器会简单地将实例中的 ItemType 替换成实例化时特别指明的类型。
** 约束 ** ** **
泛型技术还支持一种叫做约束的特性。这项功能确保在指定类型的时候,传入的类型最起码要实现某些功能。比如你要实现一种排序算法,你需要确保传入的类型能够实现 IComparible 接口。你可以用约束来完成这个设想:
Public Class SomeClass(Of ItemType As IComparible)
Public Function SomeMethod(ByVal value As ItemType) As ItemType
End Function
End Class
** 结论 ** ** **
泛型技术相对于以 Object 为基础的集合提供了很多好处,首先,泛型类是强类型的,这就确保所有的错误在编译时能够发现。强类型还可以让智能感知提供更多方便。泛型还能让你简化代码,让你的算法可以作用于多种类型。最后,泛型集合要比以 Object 为基础的集合快得多,特别是用于值类型时。