C# 泛型的简单理解(安全、集合、方法、约束、继承)分享

前言

泛型允许你在编译时实现类型安全。它们允许你创建一个数据结构而不限于一特定的数据类型。然而，当使用该数据结构时，编译器保证它使用的类型与类型安全是相一致的。泛型提供了类型安全,但是没有造成任何性能损失和代码臃肿。在这方面，它们很类似于c++中的模板，不过它们在实现上是很不同的。

使用泛型集合

 .net 2.0的system.collections.generics 命名空间包含了泛型集合定义。各种不同的集合/容器类都被"参数化"了。为使用它们,只需简单地指定参数化的类型即可。

arraylist array = new arraylist();
            array.add(3);
            array.add(4);
            array.add(5.0);
            int total = 0;
            foreach (int val in array)
            {
                total = total + val;
            }
            console.writeline("total is {0}", total);

这段代码编译肯定没问题的，不过在运行的时候就会报错。因为在foreach哪里定义的都是int，而在添加的是5.0很明显是个double类型的。

list<int> alist = new list<int>();
            alist.add(3);
            alist.add(4);
            //alist.add(5.0);
            int totallist = 0;
            foreach(int val in alist)
            {
                totallist = totallist + val;
            }
            console.writeline("total is {0}", totallist);

这段代码其实也没什么问题，如果把注释的哪一行的注释去掉，那么在编译的时候就直接报错了，因为编译器指出它不能发送值5.0到方法add(),因为该方法仅接受int型。

不同于arraylist,这里的代码实现了类型安全。

clr对于泛型的支持

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

接下来创建一个简单的泛型类

public class mylist<t>
    {
        private static int objcount = 0;
        public  mylist()
        {
            objcount++;
        }

        public int count
        {
            get { return objcount; }
        }
    }

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

public 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();
        }
    }

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

前面两个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。怎么能证明这一点？请看下图显示出的使用工具ildasm.exe生成的msil代码。

泛型方法

 除了有泛型类，你也可以有泛型方法。泛型方法可以是任何类的一部分。

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);
            console.readline();
        }

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

约束机制及其优点

 一个泛型类允许你写自己的类而不必拘泥于任何类型，但允许你的类的使用者以后可以指定要使用的具体类型。通过对可能会用于参数化的类型的类型施加约束，这给你的编程带来很大的灵活性--你可以控制建立你自己的类。让我们分析一个例子：

        public static t max<t>(t op1, t op2)
        {
            if (op1.compareto(op2) < 0)
                 return op1;
            return op2;
        }

编译代码将会有一个错误。

假定我需要这种类型以支持compareto()方法的实现。我能够通过加以约束--为参数化类型指定的类型必须要实现icomparable接口--来指定这一点。

        public static t max<t>(t op1, t op2)where t:icomparable
        {
            if (op1.compareto(op2) < 0)
                 return op1;
            return op2;
        }

好了，我指定的约束是，用于参数化类型的类型必须继承自(实现)icomparable。现在可以编译成功，并且调用了。

下面的约束是可以使用的：

　　where t : struct 类型必须是一种值类型(struct)

　　where t : class 类型必须是一种引用类型(class)

　　where t : new() 类型必须有一个无参数的构造器

　　where t : class_name 类型可以是class_name或者是它的一个子类

　　where t : interface_name 类型必须实现指定的接口

　　你可以指定约束的组合，就象: where t : icomparable, new()。这就是说，用于参数化类型的类型必须实现icomparable接口并且必须有一个无参构造器。

继承与泛型

一个使用参数化类型的泛型类，象myclass1＜t＞，称作开放结构的泛型。一个不使用参数化类型的泛型类，象myclass1＜int＞,称作封闭结构的泛型。

你可以从一个封闭结构的泛型进行派生；也就是说，你可以从另外一个称为myclass1的类派生一个称为myclass2的类，就象：

public class myclass2＜t＞ : myclass1＜int＞

你也可以从一个开放结构的泛型进行派生，如果类型被参数化的话，如：

public class myclass2＜t＞ : myclass2＜t＞

是有效的，但是

public class myclass2＜t＞ : myclass2＜y＞

是无效的,这里y是一个被参数化的类型。非泛型类可以从一个封闭结构的泛型类进行派生，但是不能从一个开放结构的泛型类派生。

public class myclass : myclass1＜int＞

是有效的, 但是

public class myclass : myclass1＜t＞

是无效的。