本帖最后由 群发软件 于 2017-5-16 13:13 编辑
数组是程序中经常要使用到的一种数据类型，Visual Basic.Net中的数组，虽然语法结构等方面保留了和Visual Basic的很多相似之处，但也与Visual Basic存在着很多区别。其最大，也是各位Visual Basic程序员所最不能容忍的区别就是如下二点：
1. 在Visual Basic .Net中申明一个数组，其数组元素中的索引值的起点全部都为“0”，而不是以前Visual Basic中的索引值起点一般都为“1”。这种定义方法和Visual Basic .Net的孪生姐妹Visual C＃非常相似。
2. 由于在Visual Basic .Net中数组都有了统一的起点，所以在Visual Basic .Net中定义一个数组，也就不再需要关键字“To”来设定数组的范围。这样在Visual Basic .Net中申明一个数组将会比Visual Basic中要稍微简洁一点。关于数组定义将在后面详细介绍。
一．本节主要内容：
在接下来内容中，将结合具体示例来详细的介绍下列知识点：
1. 申明数组，其中包括一维数组、多维数组，也包括静态数组和动态数组，及其初始化。和访问数组中的元素。
2. 重新申明数组，即ReDim语句的使用用法，及其Preserve关键字的作用。
3. 使用For Each …. Next语句来遍历数组中各个元素，For Each …. Next语句是操作数据最为常用的一种语句，它能够方便的访问到数组中的每一个元素。
4. 申明参数为数组的过程或者函数，由于数组是引用类型，所以在申明参数为数组的函数或过程时，处理方法与参数为值类型的函数或过程有点不一样。
5. 简要介绍Array类和其主要的常用，以及通过Array类操作数组的具体方法。
在Visual Basic.Net申明一个数组使用的依然是Dim语句，其申明数组和Visual Basic的主要区别在上面内容中已经简单说过了。下面在Visual Basic .Net申明一个长度为“3”的字符串数组，并对之进行初始化的代码：
Dim arrString ( 2 ) As String = {"星期一","星期二","星期三"}
下面代码是申请一个2×2的二维字符串数组，并对之进行初始化：
Dim arrDate ( 1, 1 ) As String = {{"星期一", "18号"}, {"星期二", "19号"}}
静态数组和动态数组的区别就在于静态数组的长度是固定的，而动态数组的长度是不固定的。上面的申明的二个数组就是静态数组，而下面二段代码的作用就是分别申明一个一维数组和二维数组，并对它们进行初始化：
Dim arrString ( ) As String = {"星期一","星期二","星期三"}
'申明一个动态的一维数组，并初始化
Dim arrDate ( , ) As String = {{"星期一", "18号"}, {"星期二", "19号"}}
'申明一个动态的二维数组，并初始化
对其他数据类型和更多维数的数组，其申明和初始化方法和上面的基本差不多，只需根据数组的维数和数据类型的不同进行相应的修改就可以了。
当数组申明和初始化以后，就可以通过元素在数组中对应的索引值来访问，下面二段代码分别是访问上面申明并初始化的一维数组和二维数组中的一个元素：
Dim sTemp1 As String = arrString ( 1 )
'访问arrString数组中的第2个元素
Dim sTemp2 As String = arrDate ( 1 , 1 )
'访问arrDate数组中的第二行、第二列元素
三．重新申明数组：
在Visual Basic .Net重新申明数组和Visual Basic中基本类似，依然使用的是ReDim语句。在Visual Basic .Net中使用ReDim语句要注意以下三点：
1. ReDim语句仅可以在过程级出现。这意味着不可以在类或模块级代码区使用ReDim语句来重新申明数组。
2. ReDim语句只是更改已被正式声明的数组的一个或多个维度的大小，但不能更改该数组的维数。
3. ReDim语句无法更改数组中元素的数据类型，和Dim语句申明数组的区别在于无法在ReDim语句中初始化重新申明的数组。
在使用ReDim重新申明数组时，最为常见的关键字就是“Preserve”。“Preserve”的作用是表明在重新申明数组时，是否要在重新申明的数组中复制原数组中的元素。请比较下面二段代码：
代码一：
Dim arrString ( 2 ) As String = {"星期一","星期二","星期三"}
ReDim Preserve arrString ( 4 )
'重新申明arrString数组，数组的长度改为5，并且在新数组中复制原数组的元素
arrString ( 3 ) = "星期四"
arrString ( 4 ) = "星期五"
代码二：
Dim arrString ( 2 ) As String = {"星期一","星期二","星期三"}
ReDim arrString ( 4 )
'重新申明arrString数组，数组的长度改为5，并不往新数组中复制原数组的元素
arrString ( 0 ) = "星期一"
arrString ( 1 ) = "星期二"
arrString ( 2 ) = "星期三"
arrString ( 3 ) = "星期四"
arrString ( 4 ) = "星期五"
通过比较上述二段代码，可见，在第一段代码中由于ReDim中使用了Preserve关键字，所以在重新申明数组时，就在新数组中复制了原数组的元素，这样就只需要对其中的二个元素进行初始化；而第二段由于没有使用Preserve关键字，就没有在新数组中带入原数组中的任何元素，所以对数组的所有元素都进行初始化。通过比较相信您对重新定义数组和“Preserve”关键字的使用有了更深的理解。
用Photoshop给漂亮的烫发MM抠图
Photoshop透明婚纱抠图大法
Photoshop:让MM做个“变色龙”
用Photoshop来制作一款精美的宝宝照片墙
Photoshop绝色美女通道抠图法
用Photoshop教你打造绚丽光芒效果
For Each …. Next语句好像只是为二种数据类型专门度身定做的，其一就是集合，另外一个就是数组了。通过For Each …. Next语句，可以十分方便的访问数组中的任一元素。请仔细分析一下下列代码：
Dim arrString ( 2 ) As String = {"星期一","星期二","星期三"}
Dim Temp As String
For Each Temp In arrString
If Temp = "星期三" Then
MsgBox ( "在数组中寻找到""星期三""字符串")
Exit For
'退出For Each …. Next语句
End If
Next
上面代码的功能是通过For Each …. Next语句访问arrString数组中各元素，如果发现有元素为字符串“星期三”，则弹出提示框，并退出循环。
同样用For … Next语句也能够实现上面同样的功能，只是感觉有点不专业，并且有点繁琐，下面代码是用For … Next语句实现上面For Each …. Next语句同等功能的代码：
Dim i As Integer
For i = 0 To myString.Length - 1
If arrString ( i ) = "星期三" Then
MsgBox ( "在数组中寻找到""星期三""字符串" )
Exit For
End If
Next
五．申明参数为数组的过程或者函数：
由于数组为引用类型，所以如果以数组为参数过程和函数在定义时候就要多加以注意，下面代码是在Visual Basic.Net申明一个参数为数组的过程的典型代码，可见在调用数组类型之前多了一个关键字“ByVal”，“ByVal”关键字的作用在于在下面调用的过程中的不能更改数组的数值：
Sub DisplayArray ( ByVal myString ( ) As String )
End Sub
六．简要介绍System.Array类及其成员：
Array类是一个基类，是公共语言运行库中所有数组的基类。它提供了创建、操作、搜索和排序数组的方法。数组中任一个元素就是Array中的一个值。Array的长度是它可包含的元素总数。Array的秩是Array中的维数。Array中维度的下限是Array 中该维度的起始索引，多维Array的各个维度可以有不同的界限。表01和表02分别是Array类的常用属性和常用方法及其说明：
属性 说明
IsFixedSize 获取指示Array是否具有固定大小的值。
IsReadOnly 获取指示Array是否为只读的值。
Length 获取Array的所有维度中的元素总数。
Rank 获取Array的秩（也就是维数）。
表01：System.Array类的常用属性及其说明
方法 说明
BinarySearch 使用二进制搜索算法在一维的排序Array中搜索值。
Clear 将Array中的一系列元素设置为零、false或空引用（即：Nothing），具体操作时设定值取决于元素类型。
Copy 将一个Array的一部分复制到另一个Array中，并根据需要执行强制类型转换和装箱。
CopyTo 将当前一维Array的所有元素复制到指定的一维Array中（从指定的目标Array索引开始）。
GetLength 获取Array的指定维度中的元素数。
GetLowerBound 获取Array中指定维度的下限。
GetUpperBound 获取Array的指定维度的上限。
GetValue 获取当前Array中指定元素的值。
LastIndexOf 返回一维Array或部分Array中某个值的最后一个匹配项的索引。
Reverse 反转一维Array或部分Array中元素的顺序。
SetValue 将当前Array中的指定元素设置为指定值。
Sort 对一维Array对象中的元素进行排序。
表02：System.Array类的常用方法及其说明
下面介绍的示例的功能包含了数组的申明、初始化、重新申明、重新初始化、数组中各元素的排序、数组的遍历、查找以及以数组为参数的过程的定义及调用方法等。下面是此示例实现的具体步骤：
1. 启动Visual Studio .Net。
2. 选择菜单【文件】|【新建】|【项目】后，弹出【新建项目】对话框。
3. 将【项目类型】设置为【Visual Basic项目】。
4. 将【模板】设置为【Windows应用程序】。
5. 在【名称】文本框中输入【数组】。
6. 在【位置】的文本框中输入【E:VS.NET项目】，然后单击【确定】按钮，这样在“E:VS.NET项目”目录中就产生了名称为“数组”的文件夹，并在里面创建了名称为【数组】的项目文件。
7. 把Visual Studio .Net的当前窗口切换到【Form1.vb（设计）】窗口，并从【工具箱】中的【Windows窗体组件】选项卡中往Form1窗体中拖入下列组件，并执行相应操作：
四个Button组件，分别用来创建一个“创建一维数组”、创建“创建二维数组”、实现对“对一维数组排序”和实现“重定义一维数组”。并在这四个Button组件拖入Form1的设计窗体后，分别双击这四个组件，这样系统会在Form1.vb文件分别产生这四个组件的Click时间对应的处理代码。
一个ListBox组件，用来显示创建的一维数组的内容。
8. 按照表03中数值来设定设定组件的主要属性：
组件类型 组件名称 属性 设置结果
Form Form1 Text 数组篇
Form1 MaximizeBox False
Form1 MinimizeBox False
Form1 FormBorderStyle FixedSingle
ListBox ListBox1 ItemHeight 12
ListBox1 Location Point ( 28 , 169 )
ListBox1 Size Size ( 246 , 136 )
Button Button1 Text 创建一维数组
Button1 FlatStyle Flat
Button2 Text 创建二维数组
Button2 FlatStyle Flat
Button3 Text 对一维数组排序
Button3 FlatStyle Flat
Button4 Text 重定义一维数组
Button4 FlatStyle Flat
【数组】项目窗体中各组件的主要属性设定数值表
并按照图01中各组件的位置、大小和排列方式来调整窗体中各个组件：
图01：【数组】项目的设计界面
9. 把Visual Studio .Net的当前窗口切换到【Form1.vb】，进入Form1.vb文件的编辑界面。然后用下列的代码替换Form1.vb中Button1组件的Click事件对应的处理代码，下列代码的功能是通过创建输入对话框来创建一个一维数组：
Private Sub Button1_Click ( ByVal sender As System.Object , ByVal e As System.EventArgs ) Handles Button1.Click
Dim i As Integer
For i = 0 To 3
arrString ( i ) = InputBox ( "请在下面文本框中输入字符串" , "请输入字符串 , 来初始化创建的一维数组！" , "Item " &i )
Next
Button3.Enabled = True
Button4.Enabled = True
DisplayArray ( arrString )
End Sub
10. 用下列的代码替换Form1.vb中Button2组件的Click事件对应的处理代码，下列代码的功能是创建一个二维数组，并进行初始化：
Private Sub Button2_Click ( ByVal sender As System.Object , ByVal e As System.EventArgs ) Handles Button2.Click
Dim arrDate ( , ) As String = {{"星期一" , "18号"} , {"星期二" , "19号"}}
'创建一个二维数组，并初始化
MsgBox ( arrDate ( 0 , 1 ) )
'访问这个二维数组中的元素
End Sub
11. 用下列的代码替换Form1.vb中Button3组件的Click事件对应的处理代码，下列代码的功能是首先定义一个名称为“DisplayArray”的过程，此过程能够对给定的一维数组中的数据进行排序，并通过ListBox显示出来。其次是定义Button3的Click事件，在此事件中对调用DisplayArray过程，对一维数组中的数据进行排序：
'定义一个过程，过程的功能是通过ListBox组件显示给定的字符串数组中各元素
Sub DisplayArray ( ByVal myString ( ) As String )
ListBox1.Items.Clear ( )
Dim Temp As String
For Each Temp In myString
ListBox1.Items.Add ( Temp )
Next
End Sub
Private Sub Button3_Click ( ByVal sender As System.Object , ByVal e As System.EventArgs ) Handles Button3.Click
Array.Sort ( arrString )
DisplayArray ( arrString )
End Sub
12. 用下列的代码替换Form1.vb中Button4组件的Click事件对应的处理代码，下列代码的功能是重新定义一维数组：
Private Sub Button4_Click ( ByVal sender As System.Object , ByVal e As System.EventArgs ) Handles Button4.Click
ReDim Preserve arrString ( 5 )
'请注意Preserve关键字的作用
Dim i As Integer
For i = 4 To 5
arrString ( i ) = InputBox ( "请在下面文本框中输入字符串" , "请输入字符串 , 来初始化重新创建的一维数组！" , "Item " &i )
Next
DisplayArray ( arrString )
End Sub
13. 保存上面的所有修改，至此【数组】项目的全部工作就完成了。此时单击快捷键F5运行程序，图02、图03是程序编译后的运行界面：
图02：输入字符串来初始化一维数组的界面
图03：对一维数组中的各元素进行排序后的界面
八．总结：
本文首先介绍了Visual Basic .Net中的数组和原先版本的Visual Basic中的区别，在Visual Basic .Net中数组从内涵上更像Visual C＃。其次介绍了数组的申明方法，其中包括一维数组、多维数组，也包括静态数组和动态数组，初始化数组，及其访问数组中的元素。接着介绍了重新申明数组方法，即ReDim语句的使用用法，及其Preserve关键字的作用。以及使用For Each …. Next语句来遍历数组中各个元素，For Each …. Next语句是操作数据最为常用的一种语句，它能够方便的访问到数组中的每一个元素。比用For ……Next语句要方便了许多。最后介绍在以数组为参数的过程和函数的调用方法，和Array类和其主要的使用方法。之所以提出来介绍以数组为参数的过程和函数的调用方法，是因为数组是引用类型，所以在申明参数为数组的函数或过程时，处理方法与参数为值类型的函数或过程有点不一样。Array是.Net FrameWorkSDK中提供用来操作数组的类，本文主要是介绍利用Array类操作数组的具体方方法法。以上就是本文的主要内容，相信仔细阅读并进行相应练习的读者一定已经掌握了。
我们都知道在所有程序设计语言中数组都是一个非常重要的概念，数组的作用是允许程序员用同一个名称来引用多个变量，因此采用数组索引来区分这些变量。很多情况下利用数组索引来设置一个循环，这样就可以高效地处理复杂的情况，因此在很多情况下，使用数组可以缩短或者简化程序的代码。本文主要介绍VB.NET数组的使用，希望对大家的使用带来帮助。
数组中的第一个元素的下标称为下界，最后一个元素的下标称为上界，其余的元素连续地分布在上下界之间，并且数组在内存中也是用连续的区域来存储的，所以要求声明数组每维的长度不能超过Long数据类型的最大值，即264—1=263。
我们把VB．NET数组当作一个对象来处理，这就意味着数组类型是单个引用类型，数组变量包含指向构成数组元素、数组维和数组长度等数据的指针，数组之间互相赋值其实只是在相互复制指针，而且数组继承了System名字空间的Array类。
VB．NET中提供的数组类型和VB 6.0中有一些差别，我们将在下面做详细的讲解。
(1)VB．NET数组的声明
VB．NET中的数组有两种类型：定长数组和动态数组。这里先介绍定长数组的几种不同的声明方式，不同的声明方法将导致数组不同的有效范围。
◆Dim语句在模块段建立模块级数组，例如：
◆Public语句在模块的声明部分建立一个公共数组，例如：
- Public counttype(20)as string
◆Static语句声明一个过程内的局部数组，例如：
- Public Sub Ipaddress()
- Static server(30)as string
- End Sub
VB．NET还提供了新的数组初始化语法，只需要简单的语句就可以完成数组的声明和初始化，例如：
- New array initialization syntax
- Dim arrayl As Integer()={2，4，8}
在VB．NET中，为了和其他语言更加易于协同操作，数组的下标均设定为0，不允许声明一个下界为1的数组，因此Option Base语句不再被VB．NET支持，而且在声明一个数组时必须用它的元素个数，而不是它的上界来初始化，例如：
- ／／声明一个一维数组具有3个元素，下标从0～2
- Dim arrayl(3)As Integer
- arrayl(0)：2
- arrayl(1)=4
- arrayl(2)=8
以上声明的数组有三个元素，下标从0到2，如果代码企图访问下标为3的数组元素，将引起运行错误。
(2)二维数组及多维数组
除了较为简单的一维数组外，VB．NET还支持多维数组，其声明方法和一维数组没有太大的区别，例如：
- StatiC multidim(10，10)as double
- Public Singledim(5，8，10，3)as single
以上语句声明了一个lO行，10列的二维数组。在VB．NET中，数组最多有32维，而且每一维的长度都不能够超过Long数组类型的最大值。数组总尺寸的限制是不一样的，这与所采用的操作系统以及计算机中使用的内存量有关。数组的维数将保留在System．Array．Rank属性中，每维的长度可以由System．Array．GetLengfll方法来得到。需要提醒注意的是，由于VB．NET中数组是以0为基的，如果返回来的值为9，则表示数组是10维的。当为数组继续添加维数的时候，使其扩展为多位数组，此时会使数组所需的存储空间大幅度增加，所以在使用多维数组时对这个方面也要多加考虑。
另外VB．NET还提供了Lbound()和Lbound()两个函数来返回数组的上、下界。中国自学编程网整理发布 ，www.zxbc.cn对于一维数组而言，只需要一个参数，那便是数组名。例如：
对于多位数组，也只是简单地将逗号后面的第二个参数指定为数组的第几维。例如：
如果没有指明是哪一维，系统默认为第一维。
(3)动态数组
有时在程序运行之前无法确认数组的大小，VB．NET提供了在程序运行时动态决定数组大小的功能，即动态数组。它具有灵活多变的特点，可以在任何时候根据需要随时改变数组的大小，有助于内存的管理。建立一个动态数组的详细步骤如下：
①和声明一般数组一样，可以使用前面介绍的几种声明，只是赋一个空维数组，这样就将数组声明为动态数组。典型的声明语句为：
②然后使用ReDim语句来配置数组大小。ReDim语句声明只能在过程当中使用，它是可执行语句，可以改变数组中元素的个数，但是却不可以改变数组的维数，就是说不能把一维变为二维。在ReDim语句配置数组元素个数时，数组中的内容将全部置为0。典型语句为：
③如果想改变数组大小又不想丢失原来的数据，只要在ReDim语句中包含Preserve关键字就可以，典型语句为：
- ReDa_m PresetVe Types(10，23)
对于多维数组，在使用Preserve关键字时，只能修改最后一维的大小。如果改变其他维，那么将出现运行错误。如果不清楚某维的当前大小，可以使用GetI~ength函数来获取。
(4)VB．NET数组的使用
在’VB 6．0中，可以用For Each来循环遍历一个数组。例如：
- Dim x As Integer
- F0r Each x In arrayl
- Console．WriteLine(x)
- Next
在VB．NET中可以使用For循环和数组长度来遍历一个数组。例如：
- Dim i As工nteger
- F0r i=0 T0 (arrayl．Length-1)
- Console．WriteLine(arrayl(1)J
- Next i
在使用数组时还要注意，不仅声明语法有变化，而且在运行时处理方式也有了很大的变化。VB．NET在堆栈中给数组分配地址空间，当向一个方法传递数组类型的参数时，使用的是引用传递而不是值传递。下面是互相传递数组引用的三个方法：
- Dim arrayl(3，3)AS Integer
- Dim array2 As Integer(，)
- Redim array2(3，3)
- Dim array3 As Integer(，)={{2，4}，{12，29}}
方法一在两个方向同时传递了数组引用，一般用来向调用者返回数组引用。方法二和方法三从调用者向方法的实现中传递了数组引用。方法二的参数被声明为一维数组，而在方法三中参数被声明成了-维数组。
(5)数组的高级特性
①数组的数组
在O~ect数组中还可以组装不同类型的数组。例如，以下代码中先建立两个数组，一个是Integer类型，另一个是String类型，然后再声明一个O~ect类型的数组，把前两个数组分装在其中。
- Dim I as integer
- ／／声明一个integer类型的数组
- Dim grade(15)as integer
- For i：0 tO 14
- Grade(i)=i
- NeXt i
- ／／声明一个string类型的数组
- Dim name(15)as String
- For i=0 tO 14
- Name(i)：”Student”＆cstr(i)
- Next i
- ／／声明一个新的数组为object，用来组装其他数组
- Dim Student(2)as object
- Student(0)=grade
- Student(1)=name
- Msgbox(student(0)(2)) ／／显示”2”
- Msgbox(student(1)(3)) ／／显示”student 3”。
上述代码中使用了student(0)和student(1)的后绑定。注意，只有在Option s~ict被关闭时，VB．NET编译器才允许使用后绑定。
②数组和集合
虽然集合通常用于操作对象，但是它也能操作数据类型。在某些条件下，其效率比数组还要高。我们可以通过以下4个方面来进行比较。
◆集合可以根据需要进行扩充，不像数组那样需预先规定大小。
◆数组只能保存声明时所定义的数据类型，但是同一个集合中可以存储不同类型的数据。
◆集合元素的修改较为麻烦，不像数组那么方便。
◆处理集合的速度较数组慢，但是在处理较小的动态条目集，使用集合是最为理想的选择。
变量、数组、集合、泛型的发展
最开始用内存中一个位置映射一个值，用变量来“使用”这个值。
进一步发展，用变量来引用一组值，这就是数组。由数组概念，发展出链表、堆、栈，进行排序、检索等。
但这并不能完全表达，由此发展出集合概念，它是更强大的数组，都依赖于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
由于上面同时是接口所以可以用CompareTo方法：
If current.Value.CompareTo(value) > 0 Then
上面是限定为接口，下面还可限定为子类（Windows窗体控制Control)
同时也是在方法中限定（上面是在泛型类型中）：
[vb] view plain copy
print?
- '约束类型参数必须是某类的子类（下例为Control的泛型方法）
- Public Shared Sub ChangControl(Of C As Control)(ByVal con As C)
- con.Anchor = AnchorStyles.top Or AnchorStyles.left
- End Sub
-
-
-
- '===========================================================
- '约束类型参数为特定的泛型
- Public Class ListClass(Of T, V As Generic.List(Of T))
- 'add code
- End Class
- '使用时这样：
- Dim list As ListClass(Of Integer, Generic.List(Of Integer))
上面还限制了部分参数须是某泛型类型（V）
2、类、结构的约束
下面限制类型参数必须是值类型或引用类型：
[vb] view plain copy
print?
- '约束（限制）类型参数是引用类型
- Public Class ReferenceOnly(Of T As Class)
- 'add code
- End Class
-
-
- '约束(限制）类型参数是值类型
- Public Class ValueOnly(Of T As Structure)
- 'add code
- End Class
3、New约束
有时需创建类型参数定义的类型实例，必须使用New约束，来确保该类型有默认的公共构造函数。
[vb] view plain copy
print?
- Public Class Factories(Of T As New)
- Public Function CreateT() As T '必须确保T有默认的构造函数，否则出错
- Return New T
- End Function
- End Class
类型参数T必须有公共的默认构造函数。若给T没指定构造函数的类型会出错。有了T的默认构造函数后，就可以CreateT创建实例。
4、多个约束
可以指定类型参数为几个约束，用花括号。
下面约束：必须是引用类型，且必须有公共的默认构造函数：
[vb] view plain copy
print?
- Public Class Factories(Of T As {New, Class}) '限制类型参数可以为多种情况(花括号）
- Public Function CreateT() As T
- Return New T
- End Function
- End Class
5、泛型与后期绑定
泛型的变量与参数在模板代码中被当作Object处理，虽然用约束解决了部分问题、扩展了变量类型，但仍受限制。
比如，并不知道指定的类型是否支持+-等运算符重载：
[vb] view plain copy
print?
- Public Function Add(Of T)(ByVal a As T, ByVal b As T) As T
- Return a + b '错误，因不知道是否支持运算符重载
- End Function
-
- '改为下面(option strict off)
- Public Function Add1(Of T)(ByVal a As T, ByVal b As T) As T
- Return CObj(a) + CObj(b) '此时应重载+，这样才不会出错
- End Function
五、协变与逆变
协变逆变利用继承关系 对不同参数类型或返回值类型 的委托或者泛型接口之间做转变。
协变和逆变是说明父类与子类的相互转换。
简单地说：子--》父（协变）；父--->子（逆变）
因为子到父的转换永远正确（协变），而父到子的转换不一定正确所以也称（逆变）
例如Animal是父类，Dog是从Animal继承的子类。
如果一个方法要接受Dog参数，那么另一个接受Animal参数的方法肯定也可以接受这个方法的参数，这是Animal向Dog方向的转变是逆变。
如果一个方法要求的返回值是Animal，那么返回Dog的方法肯定是可以满足其返回值要求的，这是Dog向Animal方向的转变是协变。
它们的主要应用场合是多态。
1、协变
子--->父
[vb] view plain copy
print?
- '父类
- Public Class Parent(Of T)
- 'add code
- End Class
-
- '子类
- Public Class ChildClass(Of T)
- Inherits Parent(Of T)
-
- 'add code
- End Class
-
- '多态应用中，协变
- Public Class CoVariance
- Public Sub MainMethod()
- Dim cc As New ChildClass(Of String)
- Dim dad As Parent(Of String)
-
- dad = cc '子类赋值给父类，协变
- End Sub
- End Class
2、逆变
父---->子
[vb] view plain copy
print?
- '父类
- Public Class Base
-
- End Class
-
- '子类
- Public Class Derived
- Inherits Base
-
- End Class
-
- '应用(泛型逆变）
- Public Class ContraVariance
- '封装一个方法，有一个参数且无返回值，即baseMethod(byval param as Base)
- Private baseMethod As Action(Of Base) = Sub(param As Base)
- 'add code
- End Sub
- 'derivedMethod(byval param as Derived)
- Private derivedMethod As Action(Of Derived) = baseMethod
-
- Public Sub MainMethod()
- Dim d As Derived = New Derived()
-
- derivedMethod(d)
- baseMethod(d)
- End Sub
- End Class
[url=]
[/url]
|( 京ICP备09078825号 )
发表于 2017-5-16 13:10:26
收藏
