泛型，作为.net 2.0 的一个新特性出现，带给开发人员很大的便利。下面了解下泛型的一些基础知识：
什么是泛型？？
所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型，泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。
泛型的作用
C#泛型赋予了代码更强的类型安全，更好的复用，更高的效率，更清晰的约束。
下面通过一个例子来对其作用或者是说其优势进行讲解（讲解部分见代码注释）。
class Program
{
#region Main
/// <summary>
/// 实例化一个ArrayList和一个List<int>,然后往其中加入成员,最后分别读取出第一个成员,
///进行一个加法操作
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
#region ArrayList
/***************************************************************************
* ArrayList的缺点:每一个成员都必须是object对象
*1:处理值类型时，出现装箱、折箱操作，影响性能。list1.Add(1)时会发生装箱。
*2:处理引用类型时，虽没有装箱和折箱操作，但仍需要类型转换操作。
*代码list1.Add("a")不会发生装箱。
*3:程序运行时的类型转换可能引发异常。运行(int)list1[1]时，由于它是一个字符串，
*要强制转换成int就会有异常。
***************************************************************************/
ArrayList list1 = new ArrayList();
list1.Add(1);
list1.Add("a");
int i = (int)list1[0] + 1;
#endregion
#region List<int>
/***************************************************************************
* 泛型用一个通用的数据类型T来代替object，在类实例化时指定T的类型，
*CLR自动编译为本地代码，
* 并且保证数据类型安全。
* 泛型优点：
* 1:类型安全的。例如实例化了int类型的类，就不能处理string类型的数据。
*下面的list2.Add("a"),就会报错。
* 2:处理值类型时,无需装箱和折箱。int j=i+1;i可以直接取，并不需要折箱操作。
* 3:无需类型转换,包含值类型和引用类型。
**************************************************************************/
List<int> list2 = new List<int>();
list2.Add(1);
//list2.Add("a");
int j = (int)list2[0] + 1;
#endregion
Console.ReadKey();
}
#endregion
}
下面我们来看下它生成的IL代码：
.maxstack 2
.locals init ([0] class [mscorlib]System.Collections.ArrayList list,
[1] class [mscorlib]System.Collections.ArrayList list1,
[2] int32 i,
[3] class [mscorlib]System.Collections.Generic.List`1<int32> list2,
[4] int32 j,
[5] class [mscorlib]System.Collections.ArrayList '<>g__initLocal0')
IL_0000: nop
IL_0001: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor()
IL_0006: stloc.s '<>g__initLocal0'
IL_0008: ldloc.s '<>g__initLocal0'
IL_000a: ldc.i4.1
IL_000b: box [mscorlib]System.Int32
IL_0010: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_0015: pop
IL_0016: ldloc.s '<>g__initLocal0'
IL_0018: stloc.0
IL_0019: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor()
IL_001e: stloc.1
IL_001f: ldloc.1
IL_0020: ldc.i4.1
IL_0021: box [mscorlib]System.Int32
IL_0026: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_002b: pop
IL_002c: ldloc.1
IL_002d: ldstr "a"
IL_0032: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_0037: pop
IL_0038: ldloc.1
IL_0039: ldc.i4.0
IL_003a: callvirt instance object [mscorlib]System.Collections.ArrayList::get_Item(int32)
IL_003f: unbox.any [mscorlib]System.Int32
IL_0044: ldc.i4.1
IL_0045: add
IL_0046: stloc.2
IL_0047: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor()
IL_004c: stloc.3
IL_004d: ldloc.3
IL_004e: ldc.i4.1
IL_004f: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0)
IL_0054: nop
IL_0055: ldloc.3
IL_0056: ldc.i4.0
IL_0057: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1<int32>::get_Item(int32)
IL_005c: ldc.i4.1
IL_005d: add
IL_005e: stloc.s j
IL_0060: ret
第一：ArrayList与List<T>的构造函数说明了泛型的类型安全优点：
1:实例化ArrayList:
2:实例化List<T>:
第二： IL_000b: box [mscorlib]System.Int32这条语句表明一个整数被加入到ArrayList时会出现装箱。而List<int>的IL代码中并没有出现box语句。这点可以证明泛型的优点二。
第三：两者读取成员的操作不同可以说明泛型的优点三。
1：下面的语句表明当从ArrayList中读取一个成员时，需要进行拆箱操作。
IL_003f: unbox.any [mscorlib]System.Int32
2：下面的代码表明从List<int>中读取一个成员时，不需要进行拆箱操作。
IL_005c: ldc.i4.1
泛型类实例化的理论：C#泛型类在编译时，先生成中间代码IL，通用类型T采用特殊的占位符来表示，并用专有的IL指令支持泛型操作。在实例化类时，根据用户指定的数据类型代替T并由即时编译器(JIT)生成本地代码，这个本地代码中已经使用了实际的数据类型。
泛型中的静态成员变量：在C#1.x中，类的静态成员变量在不同的类实例间是共享的,C#2.0中,静态成员变量在相同封闭类间共享，不同的封闭类间不共享。示例代码:
class Program
{
#region Main
static void Main(string[] args)
{
Point<int> point = new Point<int>(1);
Point<int> point1 = new Point<int>(2);
Point<long> point2 = new Point<long>(2);
Console.WriteLine(point.ToString()); //结果为2
Console.WriteLine(point1.ToString()); //结果为2
Console.WriteLine(point2.ToString()); //结果为2
Console.ReadKey();
}
#endregion
}
public class Point<T>
{
/// <summary>
/// 静态变量
/// </summary>
public static T width;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="_width"></param>
public Point(T _width)
{
width = _width;
}
/// <summary>
/// 输出width值
/// </summary>
/// <returns></returns>
public override string ToString()
{
return width.ToString();
}
}
小结：类实例point和point1是同一类型，他们之间共享静态成员变量，但类实例point2却是和point、point1完全不同的类型，所以不能和point、point1共享静态成员变量。
可以将Point<int>理解为一个平常的类，每一个Point<int>对象都能访问到Point<int>中的静态成员变量。
说明：泛型还有许多内容，像泛型委托，泛型接口，泛型方法，泛型类，泛型约束，其实上面的都是泛型的最基本的知识，其它的应用都建立在这些基础之上。
（可以参看文章链接http://www.cnblogs.com/pw/archive/2006/06/08/420635.html ）
另外推荐http://www.cnblogs.com/gjcn/archive/2008/11/25/1338407.html
http://www.cnblogs.com/jimmyzhang/archive/2008/12/17/1356727.html
浙公网安备 33010602011771号