VB.net学习笔记（十九）数组、集合、泛型

百眼通 2014-10-31

展开全文

变量、数组、集合、泛型的发展

最开始用内存中一个位置映射一个值，用变量来“使用”这个值。

进一步发展，用变量来引用一组值，这就是数组。由数组概念，发展出链表、堆、栈，进行排序、检索等。

但这并不能完全表达，由此发展出集合概念，它是更强大的数组，都依赖于Object基类。

随之而来的是集合中元素并不一定是一样的，于是都得转为Object，涉及到装箱，使性能下降，特别是元素量巨大时。而且

由于我们一般使用同一类型（强类型）更方便操作。由此产生了泛型

泛型简单地说，就是把里面的元素强制指定为特定的类型，也可以说是模板。

一、数组

1、数组的定义

System.Array类是数组的基础，数组就是由它派生而来。

所有.Net数组和集合的下标总是从0开始。故元素的个数是上限+1

数组的定义：

[vb] view plain copy print ?

Dim a1(20) As Integer
Dim a2() As Integer = {1, 2, 3, 4}
Dim a3(4, 2) As Integer
Dim a4(,) As Integer = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}}
Dim a5() As Integer

a1数组是从a1(0)到a1(20)共21个元素，而不是20个元素。20表示上限。

a2表示4个元素，上限是3，即a2(3)

a3表示的是二维数组

a4也是二维，但其一维和二维的上限由后面的值来确定。

a5表示是不定数组，将在后面的使用中来确定，它是一个重要的概念

2、多维数组

UBound用来提取数组中某维中的上限（注意不是个数），LBound是提取数组的下限，由于下限永远是从0开始，所以这个函数没用了。

另外维数是从左到右，从1开始计数（这与元素索引从0开始计数不同）

需要注意的是： GetUpperBound(0)也是提取上限，例如 : a1.GetUpperBound(0)

它的维数却是以0开始，相当于UBound中维数的1

[vb] view plain copy print ?

Module Module1
Sub Main()
Dim a(,) As Int32 = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}}
Dim temp As Int32
For i As Int32 = 0 To UBound(a) '即UBound(a,1)
For j As Int32 = 0 To UBound(a, 2) '将返回其最大可用下标的维度。对第一维使用 1，对第二维使用 2，
temp += a(i, j) '依此类推。如果省略 Rank，则假定为 1。
Next
Next
Console.WriteLine(temp)
Console.Read()
End Sub
End Module

3、不定数组

就是声明时并没有实例化的数组，它只是说明了类型，却没有在内存中分配空间（因为元素个数未定）

因此，它没有具体实例化前是不能直接使用的，如图，出错：

未处理，其值为空。

ReDim

不定数组在使用前须用ReDim来实例化（指明个数，以便分配内存空间），但不得改变成其它类型，否则出错。

[vb] view plain copy print ?

Sub Main()
Dim a() As Int32
ReDim a(3) '只能实例化，不能声明（成类型）
Console.WriteLine(a(0))
Console.Read()
End Sub

注意：ReDim与VB6中不同：（1）须先声明类型，再用ReDim，不能用ReDim来声明（成其它类型）

（2）不能改变数组维数（增加或减少都不行）

Preserve

保持之意。不定数组经ReDim实例化后，还可再次用ReDim来改变，第二次改变会直接改变第一次实例化中重叠的元素。

为了保持元素值，用Preserve来指明。

注意Preserve只能修改最后一维的大小。

[vb] view plain copy print ?

Sub Main()
Dim a(,) As Int32
ReDim a(6, 5)
a(6, 1) = 3
ReDim a(7, 4) '正确，无Preserve时，可以修改多维
'ReDim Preserve a(5, 4) '错误，有Preserve时，只能修改最后一维的大小
Console.WriteLine(a(6, 1))
Console.Read()
End Sub

二、集合

数组功能很强大，但Array基类并没为数组提供更多的功能，比如排序、动态分配内存。为了更强大的功能产生了集合。

集合（Collections)名称空间是System名称空间的一部分，它提供系列高级功能。

对不同的用处，System.Collections名称空间提供了几个强大的类：

ArrayList 实现一个数组，其大小在添加元素时自动增加大小（不必烦恼数组的上限或用ReDim、Preserve）

BitArray 管理以位值存储的布尔数组

Hashtable 实现由键组织的值的集合（Key,Value)，排序是基于键的散列完成的（哈希函数）

Queue 实现先进先出集合（排序方式）

Stack 实现后进先出集合

SortedList 实现带有相关的键的值的集合，该值按键来排序，可以通过键或索引来访问

1、ArrayList 数组列表

ArrayList 仅一维且不保证是排序的。可使用一个整数索引访问此集合中的元素。此集合中的索引从零开始。

在执行需要对 ArrayList 排序的操作（如 BinarySearch）之前，必须对 ArrayList 进行排序。

ArrayList 的容量是 ArrayList 可以包含的元素数。随着向 ArrayList 中添加元素，容量通过重新分配按需自动增加。
可通过调用 TrimToSize 或通过显式设置 Capacity 属性减少容量。对于非常大 ArrayList 对象，则在运行时环境
(ide) 中增加最大容量为 20亿在 64 位系统的元素通过设置 gcAllowVeryLargeObjects 配置元素的 enabled 属性设置为 true 。

ArrayList 集合接受 null 引用（在 Visual Basic 中为 Nothing）作为有效值并且允许重复的元素。

[vb] view plain copy print ?

Module Module1
Sub Main()
'使用大小会根据需要动态增加的数组来实现 IList 接口
Dim objArryList As New System.Collections.ArrayList
Dim objItem As Object
Dim intLine As Int32 = 1
Dim strHello As String = "Hello"
Dim objWorld As New System.Text.StringBuilder("World")
objArryList.Add(intLine)
objArryList.Add(strHello)
objArryList.Add(" "c)
objArryList.Add(objWorld)
objArryList.Insert(1, ". ") '在索引1处插入。（索引从0开始）
For Each objItem In objArryList
Console.WriteLine(objItem.ToString)
Next
Console.Read()
End Sub
End Module

可以看到使用很方便：1、不需要声明数组大小

2、不需要重写定义数组大小

3、不需要用Preserve来保持数据

ArrayList都会自动完成这样的功能。

2、Hashtable 哈希表

表示根据键的哈希代码进行组织的键/值对的集合。

键通过一个哈希函数来确定元素值的具体存储位置。这样就可以快速由Key取得值。

键不能是Nothing（NULL），值可以是。

优点：定位查找一个值，插入、删除一个映像的效率最高。

3、SortedList 排序列表
hashtable是没有排序的，所以新增元素会比较快。而SortedList 存储的键值对，是按key进行排序了的，

因为要排序，所以新增元素时，要先查找元素的位置再插入，相对慢些，但是在查找时比较快。

下面，每变动一次元素，自动会按Key进行排序，所以最后不需排序，就可得到排序的结果：

4、Queue 队列

表示对象的先进先出集合。

队列在按接收顺序存储消息方面非常有用，以便于进行顺序处理。此类将队列作为循环数组实现。存储在 Queue 中的对象在一端插入，从另一端移除。

Queue 的容量是 Queue 可以包含的元素数。随着向 Queue 中添加元素，容量通过重新分配按需自动增加。可通过调用 TrimToSize 来减少容量。

等比因子是当需要更大容量时当前容量要乘以的数字。在构造 Queue 时确定增长因子。默认增长因子为 2.0。 Queue 的容量将始终加 4，

无论增长因子是多少。例如，当需要更大的容量时，增长因子为 1.0 的 Queue 的容量将始终增加四倍。

Queue 接受 null 引用（在 Visual Basic 中为 Nothing）作为有效值并且允许重复的元素

5、Stack 栈

表示对象的简单后进先出 (LIFO) 非泛型集合

注意：比较与Queue的输出顺序

6、循环控制

(1)For...Next...

For Each...Next...

越过循环：Contunue For

退出循环：Exit For

(2) While..End While (更常用）

Do While...Loop

Do Until...Loop

同理，越过：Continue While 或Continue Do

退出：Exit While 或Exit While

(3)Thread.Sleep()

大循环或无限循环中，会一直占用线程，给造成界面假死现象，可用Thread.Sleep（），这样仅在给定时间才执行，以避免

消耗过多的处理器时间。

while i=1

....

system.Threading.Thread.Sleep(500)

...

end while

三、泛型

1、装箱（Boxing）

（1）什么是装箱？

值类型存储在栈上，引用类型存储在堆上。

当值类型向引用类型转变，即从栈向堆上转移，这时值就变成了一对象，就好像值类型外面包装了一层东西，这个过程叫装箱（Boxing）

[vb] view plain copy print ?

'不需要装箱，都是值类型
Dim a1(20) As Integer
Dim a2 As Integer = 1
a1(0) = 0
a1(1) = a2
'需要装箱，String是引用类型
Dim b1 As New System.Text.StringBuilder()
Dim b2 As New System.Collections.SortedList()
Dim i As Integer
For i = 1 To 100
b1.Append(i) '未装箱，直接接收
b2.Add(i, i) '装箱，参数需要两个对象，要转换integer为对象
Next

（2）装箱的影响

显然装箱会使“值”的外层多了一些“无用”的东西，会使得性能稍有下降。

集合中元素都来自Object（引用类型），即，它是在堆上，都涉及到一个装箱，如果数据量大时，性能下降得就可观了。

当需要时其中的“值”时，又需要把箱子，从堆上转移到栈上，即引用类型变成值类型，这个过程叫拆箱。

（3）为什么要有泛型？

集合中，任何引用或值类型都将隐式地向上强制转换为Object。如果项是值类型，添加到列表中时，进行装箱操作，在检索时进行取消装箱操作。

这样，强制转换以及装箱和拆箱操作都会降低性能。

另一个限制是缺少编译时类型检查。同一个集合可接收不同类型，所有项都强制转换为 Object，在编译时无法检查是否可以收这种类型，还是人为

错误输入了另一个类型，同时智能感应只会提示Object的方式，使得检查错误变得艰难。

如果我们对其中的类型进行一些限制，使之成为统一的类型，虽然稍微增加了编码的复杂性，但好处是可以创建一个更安全并且速度更快的列表，

校验错误也变得容易。

鉴于这种情况，催生了泛型的产生。

2、泛型的使用

泛型主要的目的是创建强类型化的集合，使处理速度加快。所以前面使用Object的普通集合类，最好使用泛型。

泛型内置于.net中，允许定义代码模板，然后使用这个模板声明变量，它实际上是创建了一个新的数据类型。

.net基类库（BCL）里有许多泛型模板，多位于System.Collections.Generic名称空间，也有分布在其它BCL中。

泛型带来的性能提升，可以让任何使用集合数据类型的地方都应当使用泛型代替。

泛型通常使用List(of T)形式，List是类型（或者类）的名称，字母T是点位符类似于参数。它表示必须提供一个用来定制泛型

的特定类型值，同时也限定的它只能是这个类型。

[vb] view plain copy print ?

Dim data1 As New List(Of Date) '元素只能是Date类型
'===================================
Dim data2 As New ArrayList '未限定元素类型，任意。（object)
data2.Add(5)
data2.Add("xxx")
data2.Add(3.2)
For Each i As Object In data2
TextBox1.AppendText(i.ToString & Environment.NewLine)
Next

上面可以看到，当没有限定时，它是Object，因为可能是integer,String，double等，最终将转向Object。也就是说

普通集合中元素是多种情况，只有当用了泛型才进行了统一，这样处理更快。

当用了泛型后，类型参数指明后，将不能再用其它类型，如下：

[vb] view plain copy print ?

Dim data1 As New List(Of Integer) '元素只能是Integer类型
data1.Add(33) '正确
data1.Add("Hello") '错误，不能为string

泛型有两种形式：泛型类型和泛型方法

List(of T)是泛型类型，定义了完整的类型或类的模板。

泛型方法是一种方法模板，使用时必须指明方法使用的“具体类型”。

3、Nullabel 可空类型

简言之：可以有空值的类型。比如数据库有字段有integer型，但有时是DBNULL（空值），在取时会出错，这个类型就有用处了。

Nullable不是值类型。

[vb] view plain copy print ?

Dim intValue1 As New Nullable(Of Integer) '可为空的Integer类型
Dim intValue2 As Integer? '与上句等效
intValue1 = 3
intValue1 = Nothing '可为空，正确
intValue2 = Nothing

[vb] view plain copy print ?

Dim intValue1 As New Nullable(Of Integer) '可为空的Integer类型
intValue1 = Nothing
If intValue1.HasValue Then '判断是滞有值
MessageBox.Show("有值")
Else
MessageBox.Show("空值")
End If

在取得这样的类型时，当用判断来说明值的情况。

4、泛型类型

泛型有两形式：泛型类型、泛型方法。下面说明泛型类型

泛型类型是用来定义类、结构、接口的模板。在使用泛型类型声明变量时，需要提供真正（具体）的类型，以确定实际类型。

（1）泛型的基本用法

[vb] view plain copy print ?

Dim data As New Generic.Dictionary(Of Integer, String)
data.Add(3, "OK")
data.Add(4, "dz")
data.Add(1, "John")
'KeyValuePair(Of Integer, String) 键值对元素
For Each o As KeyValuePair(Of Integer, String) In data
TextBox1.AppendText(o.Key & "," & o.Value & vbCrLf)
Next
'==========================
Dim data2 As New Generic.Dictionary(Of Guid, Date)
data2.Add(New Guid, Now)
For Each o As KeyValuePair(Of Guid, Date) In data2
TextBox1.AppendText(o.Key.ToString & "," & o.Value) 'Guid须转String
Next

Generic.Dictionary(Of K，T)泛型，与List（Of T)类型类似，但需两个类型参数来提供键与值（Key，Value）。

新的Dictionary类型只接受特定类型的键与值，如上面第一个是Integer与String。第二个只接收Guid与Date。

上面是声明时的情况，下面是作返回值的情况

[vb] view plain copy print ?

Private Function reGeneric() As Generic.Dictionary(Of Integer, String) '返回值类型
Dim data As New Generic.Dictionary(Of Integer, String)
data.Add(3, "dx")
data.Add(2, "qxj")
data.Add(1, "ase")
Return data '返回泛型
End Function

可以这样调用上面函数：

[vb] view plain copy print ?

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim data As New Generic.Dictionary(Of Integer, String)
data = reGeneric() '调用，取得泛型
For Each o As KeyValuePair(Of Integer, String) In data
TextBox1.AppendText(o.Key & "," & o.Value & vbCrLf)
Next
End Sub

泛型还可以作为传参：

[vb] view plain copy print ?

Private Sub useGeneric(ByVal k As Generic.Dictionary(Of Integer, String)) '泛型作参数
'add code
End Sub

（2）继承

定义新类时，可以继承泛型类型。

例如：.net BCL定义的System.ComponentModel.BindingList(Of T)泛型类型，它用于创建支持数据绑定的集合。

可以将其作用基类，创建支持数据绑定的强类型集合。

[vb] view plain copy print ?

Public Class Form1
Dim list As New CustomerList
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
DataGridView1.DataSource = list
End Sub
End Class
Public Class Customer
Public Property Name() As String
End Class
Public Class CustomerList
Inherits System.ComponentModel.BindingList(Of Customer) '必须指明具体的类型（如Customer)
Private Sub CustomerList_AddingNew(ByVal sender As Object, ByVal e As System.ComponentModel.AddingNewEventArgs) Handles Me.AddingNew
Dim cust As New Customer
cust.Name = "<new>"
e.NewObject = cust
End Sub
End Class

上面继承时，必须指明具体类型，于是可以用BindingList(Of Customer)

常规继承概念也可以用在其中，比如：重载、重写、事件等。

5、泛型方法

泛型方法语法较复杂，较难理解。在调用泛型方法时，要使用定义该方法的类型参数外，还可以使用普通参数。

泛型方法不必只在定义的泛型类型中使用，还可以任意的类型和模块中使用泛型方法。

泛型方法的好处是：不需要使用Ctype或DirectCast转换不同类型的参数与返回值。（因为泛型是CType与DirectCast替换的机制，它实际上仍然会转换）

下面重载泛型方法：

[vb] view plain copy print ?

Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim result As Boolean
result = AreEqual(1, 2)
result = AreEqual("one", "two")
result = AreEqual(1, "two") '均正确写法，转为object比较
'使用泛型
result = AreEqual(Of Integer)(1, 2)
result = AreEqual(Of String)("one", "two") '正确写法
result = AreEqual(Of Integer)(1, "two") '错误
End Sub
'不使用泛型
Public Function AreEqual(ByVal a As Object, b As Object) As Boolean
Return a.Equals(b)
End Function
'使用泛型（重载）
Public Function AreEqual(Of T)(ByVal a As T, b As T) As Boolean
Return a.Equals(b)
End Function
End Class

泛型方法会有两套参数（分别用两个括号）：

第一套参数（第一个括号）用来定义方法中使用的类型

第二套参数（第二个括号）与我们平时的参数列表一样，只不过用T等来代替要用的类型。

上面如果在Option Strict On时

6、创建泛型类型

通过前面感性认识了：泛型类型与泛型方法。

泛型类型是定义类、结构、接口的模板，通过创建模板获得更好性能实现代码重用。

（1）泛型类

创建泛型类模板与创建普通类类似，但前者要求提供使用的类型，这样在使用时以便明确这个类型：

[vb] view plain copy print ?

'创建泛型类（定义）
Public Class SingleLinkedList(Of T) 'T可自定，但在使用中，声明时须指定明确的类型
'add code
End Class

上面在使用（声明）中，就须指明T的具体类型，T与变量命名方式一样。

下面创建链表，为了适合不同类型情况，使用泛型。在这个嵌套类中先定义结点类Node:

[vb] view plain copy print ?

Public Class SingleLinkedList(Of ValueType) '单向链表类。其中，自定类型ValueType
#Region "Node Class"
Public Class Node '每个结点由当前值、指向下一个结点的引用，这两个元素组成
Private mValue As ValueType
Public ReadOnly Property Value() As ValueType '当前结点的值
Get
Return mValue
End Get
End Property
Public Property NextNode() As Node '下个结点的引用
Public Sub New(ByVal value As ValueType, ByVal newNode As Node) '创建新结点
mValue = value
NextNode = newNode
End Sub
End Class
#End Region
End Class

这样在声明使用中就可以使用具体类型，比如用Double类型的链表：

Dim list As New SingleLinkedList(Of Double)
这时，在类的的ValueType实际上就变成了:
Private mValue As Double

实际上，在设计时（ValueType类型），被当作了Object（类型），故只能使用System.object类型上的方法：

Equals()、 GetHashValue()、 GetType()、 ReferenceEquals()、 Tostring()

这将限制我们操作，并且智能化提示也受限，后面将用约束概念，来明确选择的类型，这样扩展功能增强智能化提示。

然后，使用Node完善链表类：

[vb] view plain copy print ?

Public Class SingleLinkedList(Of ValueType) '单向链表类。其中，自定类型ValueType
#Region "Node Class"
Public Class Node '每个结点由当前值、指向下一个结点的引用，这两个元素组成
Private mValue As ValueType
Public ReadOnly Property Value() As ValueType '当前结点的值
Get
Return mValue
End Get
End Property
Public Property NextNode() As Node '下个结点的引用
Public Sub New(ByVal value As ValueType, ByVal newNode As Node) '创建新结点
mValue = value
NextNode = newNode
End Sub
End Class
#End Region
Private mHead As Node '头结点，也是当前结点。（按倒序加入结点，参看后图）
Default Public ReadOnly Property Item(ByVal index As Integer) As ValueType '获取第N个结点值
Get
Dim current As Node = mHead
For i As Integer = 1 To index
current = current.NextNode
If current Is Nothing Then
Throw New Exception("Item not found in list")
End If
Next
Return current.Value
End Get
End Property
Public Sub Add(ByVal value As ValueType) '添加结点到链表
mHead = New Node(value, mHead)
End Sub
Public Sub Remove(ByVal value As ValueType) '从链表中移除结点
Dim current As Node = mHead
Dim preNode As Node = Nothing
While current IsNot Nothing
If current.Value.Equals(value) Then
If preNode Is Nothing Then '是否为头结点
mHead = current.NextNode
Else
preNode.NextNode = current.NextNode '非头结点（参看下图）
End If
Exit Sub '已移除，退出
End If
preNode = current
current = current.NextNode
End While
Throw New Exception("Item not found in list") '链表中未找到
End Sub
Public ReadOnly Property Count() As Integer '统计结点数
Get
Dim result As Integer = 0
Dim current As Node = mHead
While current IsNot Nothing
result += 1
current = current.NextNode
End While
Return result
End Get
End Property
End Class

定义好链表类后，下面使用：

[vb] view plain copy print ?

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim list As New SingleLinkedList(Of String)
list.Add("one")
list.Add("two")
list.Add("three")
list.Add("sichuan")
list.Add("dazhou")
TextBox1.Clear()
TextBox1.AppendText(list.Count & vbCrLf)
For i As Integer = 0 To list.Count - 1 '这里只能从0，因为你不能预知是否有结点。
TextBox1.AppendText(list.Item(i) & vbCrLf)
Next
End Sub

运行，结果如下：

（2）泛型类的其它功能

Dictionay泛型有多个类型参数，还可带其它普通类型：

[vb] view plain copy print ?

Public Class MyType1(Of T, V) '带两个类型参数
Private mValue As T
Private mData As V
Public Sub New(ByVal value As T, ByVal data As V) '带两个类型参数
mValue = value
mData = data
End Sub
End Class
Public Class MyType2(Of T, V)
Private mValue As T
Private mData As V
Private mMoney As Double
Public Sub New(ByVal value As T, ByVal data As V, ByVal money As Double) '带两个类型参数及一个普通类型参数
mValue = value
mData = data
mMoney = money
End Sub
End Class

（3）类、泛型类与继承

泛型类实际上是一种特殊的类。因此也具有继承等特点。

泛型类可以继承现成的类，普通类也可继承泛型类，泛型类可以继承泛型类。还有复杂的泛型子类传回泛型父类。

[vb] view plain copy print ?

'泛型继承现成的类
Public Class MyControls(Of T)
Inherits Control
End Class
'基类泛型
Public Class GenericBase(Of T)
'add code
End Class
'类继承泛型
Public Class SubClass
Inherits GenericBase(Of Integer) '必须指明类型
'add code
End Class
'泛型继承泛型(不同类型）
Public Class GenericSubClass1(Of T)
Inherits GenericBase(Of Integer) '必须指明类型
'add code
End Class
'泛型继承泛型
Public Class GenericSubClass2(Of V) '在使用时（声明）指明V类型
Inherits GenericBase(Of V) '与上V相同，故类型由子类传递回父类
'add code
End Class
'复杂子类泛型传递回父类
Public Class GenericSubClass3(Of V)
Inherits GenericBase(GenericBase(of V)) '子类型传回父类
'add code
End Class

（4）结构、接口中使用泛型

结构与类一样，在结构中也可以使用泛型：

[vb] view plain copy print ?

'结构中使用泛型
Public Structure MyCool(Of T)
Public value As T
End Structure

这样，在使用时就可以: Dim data as MyCool(Of Guid)

还可以定义泛型类接口类型。

泛型接口与泛型类、泛型结构有所不同：它的实现依赖其它类型：

[vb] view plain copy print ?

'接口使用泛型
Public Interface Icool(Of T)
Sub DoWork(ByVal data As T)
Function GetAnswer() As T
End Interface
Public Class ARegularClass
Implements Icool(Of String) '必须指明类型
Implements Icool(Of Integer)
'============String时情况==============
Public Sub DoWork(data As String) Implements Icool(Of String).DoWork
'add code
End Sub
Public Function GetAnswer() As String Implements Icool(Of String).GetAnswer
'add code
End Function
'==========Integer时情况=================
Public Sub DoWork1(data As Integer) Implements Icool(Of Integer).DoWork
'add code
End Sub
Public Function GetAnswer1() As Integer Implements Icool(Of Integer).GetAnswer
'add code
End Function
End Class

上面泛型接口定义中无法明确类型，它依赖于ARegularClass中接口类型的定义（有两个：Integer、String）

7、创建泛型方法

泛型方法也可以泛型类（类、结构、接口）中实现。

也可以在普通（类、结构、接口、模块）中实现，只不过此时的类型参数是在方法指定（而不是在类、结构、接口上指定）

下面泛型方法在普通中，故类型直接在方法中指定（T)：

[vb] view plain copy print ?

'模块中使用泛型
Public Module Comparisons1
Public Function AreEqual(Of T)(ByVal a As T, ByVal b As T) As Boolean
Return a.Equals(b)
End Function
End Module
'类中使用泛型
Public Class Comparisons2
Public Function AreEqual(Of T, R)(ByVal a As T, ByVal b As R) As R '返回也可为R
'add code
End Function
End Class

四、约束（限制）

泛型类型、泛型方法在编写代码时，类型参数都被当作System.Object类型处理，这限制了使用类型参数的参数与变量的功能。

即，只能进行赋值和调用所有System.Object变量的几个方法，大大限制了泛型的用途。

约束就是来突破这种限制，并提供控制机制。约束提供指定规则，声明运行时可以代替类型参数类型。

使用约束，可以限定类型参数必须是一个类或结构，也可限定类型参数必须实现接口或继承某基类。这样智能提示就生效了。

通俗地说：约束暗示了某具体类型，使得智能提示生效。

1、类型约束

这是常用约束，它限制某类型参数必须是指定类的子类或者必须实现指定的接口。

改变上面的链接类成为ComparableLinkedList，这里泛型指明了ValueType，同时也指明它是一个接口IComparable。

因此，智能提示会对ValueType类型提示IComparable的属性和方法：

[vb] view plain copy print ?

Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim list As New ComparableLinkedList(Of String)
list.Add("one")
list.Add("two")
list.Add("three")
list.Add("sichuan")
list.Add("dazhou")
TextBox1.Clear()
TextBox1.AppendText(list.Count & vbCrLf)
For i As Integer = 0 To list.Count - 1 '这里只能从0，因为你不能预知是否有结点。
TextBox1.AppendText(list.Item(i) & vbCrLf)
Next
End Sub
End Class
Public Class ComparableLinkedList(Of ValueType As IComparable) '类型参数同时也是接口（用于比较）
#Region "Node Class"
Public Class Node
Private mValue As ValueType
Public ReadOnly Property Value() As ValueType
Get
Return mValue
End Get
End Property
Public Property NextNode() As Node
Public Sub New(ByVal value As ValueType, ByVal newNode As Node)
mValue = value
NextNode = newNode
End Sub
End Class
#End Region
Private mHead As Node
Default Public ReadOnly Property Item(ByVal index As Integer) As ValueType
Get
Dim current As Node = mHead
For i As Integer = 1 To index
current = current.NextNode
If current Is Nothing Then
Throw New Exception("Item not found in list")
End If
Next
Return current.Value
End Get
End Property
'=========这是原来不是接口时的添加元素的方法=========
Public Sub Add1(ByVal value As ValueType)
mHead = New Node(value, mHead)
End Sub
'======现在类型参数同时是接口（可用于比较）的方法=====
Public Sub Add(ByVal value As ValueType)
If mHead Is Nothing Then
mHead = New Node(value, mHead) '链表无结点时，直接添加
Else
Dim current As Node = mHead
Dim preNode As Node = Nothing
While current IsNot Nothing
If current.Value.CompareTo(value) > 0 Then '===关键，接口使用（比较）
If preNode Is Nothing Then
mHead = New Node(value, mHead) '链表头
Else
preNode.NextNode = New Node(value, current) '链表中
End If
Exit Sub
End If
preNode = current
current = preNode.NextNode
End While
preNode.NextNode = New Node(value, Nothing) '链表尾
End If
End Sub
Public Sub Remove(ByVal value As ValueType)
Dim current As Node = mHead
Dim preNode As Node = Nothing
While current IsNot Nothing
If current.Value.Equals(value) Then
If preNode Is Nothing Then
mHead = current.NextNode
Else
preNode.NextNode = current.NextNode
End If
Exit Sub
End If
preNode = current
current = current.NextNode
End While
Throw New Exception("Item not found in list")
End Sub
Public ReadOnly Property Count() As Integer
Get
Dim result As Integer = 0
Dim current As Node = mHead
While current IsNot Nothing
result += 1
current = current.NextNode
End While
Return result
End Get
End Property
End Class