深入浅出.NET泛型编程(1)

使用泛型集合

　　.NET 2.0的System.Collections.Generics 命名空间包含了泛型集合定义。各种不同的集合/容器类都被"参数化"了。为使用它们,只需简单地指定参数化的类型即可。请看例2:

　　例2.类型安全的泛型列表

List＜int＞ aList = new List＜int＞();
aList.Add(3);
aList.Add(4);
// aList.Add(5.0);
int total = 0;
foreach(int val in aList)
{
　total = total + val;
}
Console.WriteLine("Total is {0}", total); 

在例2中，我编写了一个泛型的列表的例子，在尖括号内指定参数类型为int。该代码的执行将产生结果"Total is 7"。现在,如果我去掉语句doubleList.Add(5.0)的注释，我将得到一个编译错误。编译器指出它不能发送值5.0到方法Add(),因为该方法仅接受int型。不同于例1,这里的代码实现了类型安全。

　　5. CLR对于泛型的支持

　　泛型不仅是一个语言级上的特征。.NET CLR能识别出泛型。在这种意义上说,泛型的使用是.NET中最为优秀的特征之一。对每个用于泛型化的类型的参数，类也同样没有脱离开微软中间语言(MSIL)。换句话说,你的配件集仅包含你的参数化的数据结构或类的一个定义，而不管使用多少种不同的类型来表达该参数化的类型。例如,如果你定义一个泛型类型MyList＜T＞，仅仅该类型的一个定义出现在MSIL中。当程序执行时,不同的类被动态地创建,每个类对应该参数化类型的一种类型。如果你使用MyList＜int＞和MyList＜double＞，有两种类即被创建。当你的程序执行时，让我们进一步在例3中分析这一点。

　　例3.创建一个泛型类

//MyList.cs
Using directives#region Using directives
using System;
using System.Collections.Generic;
using System.Text;
#endregion
namespace CLRSupportExample
{
　public class MyList＜T＞
　{
　　private static int objCount = 0;
　　public MyList()
　　{objCount++; }
　　public int Count
　　{
　　　get
　　　　{return objCount; }
　　}
　}
}
//Program.cs
Using directives#region Using directives
using System;
using System.Collections.Generic;
using System.Text;
#endregion
namespace CLRSupportExample
{
　class SampleClass {}
　class Program
　{
　　static void Main(string[] args)
　　{
　　　MyList＜int＞ myIntList = new MyList＜int＞();
　　　MyList＜int＞ myIntList2 = new MyList＜int＞();
　　　MyList＜double＞ myDoubleList = new MyList＜double＞();
　　　MyList＜SampleClass＞ mySampleList = new MyList＜SampleClass＞();
　　　Console.WriteLine(myIntList.Count);
　　　Console.WriteLine(myIntList2.Count);
　　　Console.WriteLine(myDoubleList.Count);
　　　Console.WriteLine(mySampleList.Count);
　　　Console.WriteLine(new MyList＜sampleclass＞().Count);
　　　Console.ReadLine();
　　}
　}
}

该例中，我创建了一个称为MyList泛型类。为把它参数化，我简单地插入了一个尖括号。在＜＞内的T代表了实际的当使用该类时要指定的类型。在MyList类中，定义了一个静态字段objCount。我在构造器中增加它的值。因此我能发现使用我的类的用户共创建了多少个那种类型的对象。属性Count返回与被调用的实例同类型的实例的数目。

　　在Main()方法,我创建了MyList＜int＞的两个实例，一个MyList＜double＞的实例，还有两个MyList＜SampleClass＞的实例--其中SampleClass是我已定义了的类。问题是:Count(上面的程序的输出)的值该是多少？在你继阅读之前，试一试回答这个问题。

　　解决了上面的问题？你得到下列的答案了吗？

12
22
31
41
52   
6/**//*注意：这里是2。因为这个是运行时动态创建的，在编译时，static的变量值为1，如同第一，第二行，他们都是2，因为在编译时就已经创建两个int类型的实例，所以static的值是2*/

前面两个2对应MyList＜int＞，第一个1对应MyList＜double＞，第二个1对应MyList＜SampleClass＞--在此，仅创建一个这种类型的实例。最后一个2对应MyList＜SampleClass＞，因为代码中又创建了这种类型的另外一个实例。上面的例子说明MyList＜int＞是一个与MyList＜double＞不同的类，而MyList＜double＞又是一个与MyList＜SampleClass＞不同的类。因此，在这个例中,我们有四个类：MyList: MyList＜T＞，MyList＜int＞，MyList＜double＞和MyList＜X＞。注意，虽然有4个MyList类，但仅有一个被存储在MSIL。怎么能证明这一点？请看图1显示出的使用工具ildasm.exe生成的MSIL代码。

6. 泛型方法

　　除了有泛型类，你也可以有泛型方法。泛型方法可以是任何类的一部分。让我们看一下例4:

　　例4.一个泛型方法

public class Program
{
　public static void Copy＜T＞(List＜T＞ source, List＜T＞ destination)
　{
　　foreach (T obj in source)
　　{
　　　destination.Add(obj);
　　}
　}
　static void Main(string[] args)
　{
　　List＜int＞ lst1 = new List＜int＞();
　　lst1.Add(2);
　　lst1.Add(4);
　　List＜int＞ lst2 = new List＜int＞();
　　Copy(lst1, lst2);
　　Console.WriteLine(lst2.Count);
　}
}

Copy()方法就是一个泛型方法，它与参数化的类型T一起工作。当在Main()中激活Copy()时，编译器根据提供给Copy()方法的参数确定出要使用的具体类型。