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＞

是無效的。