C# 泛型的簡單理解(安全、集合、方法、約束、繼承)分享

2020-01-24 03:06:32

字體：大中小

供稿：網(wǎng)友

前言

泛型允許你在編譯時實現(xiàn)類型安全。它們允許你創(chuàng)建一個數(shù)據(jù)結(jié)構(gòu)而不限于一特定的數(shù)據(jù)類型。然而，當使用該數(shù)據(jù)結(jié)構(gòu)時，編譯器保證它使用的類型與類型安全是相一致的。泛型提供了類型安全,但是沒有造成任何性能損失和代碼臃腫。在這方面，它們很類似于C++中的模板，不過它們在實現(xiàn)上是很不同的。

使用泛型集合

.NET 2.0的System.Collections.Generics 命名空間包含了泛型集合定義。各種不同的集合/容器類都被"參數(shù)化"了。為使用它們,只需簡單地指定參數(shù)化的類型即可。

復(fù)制代碼代碼如下:

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類型的。

復(fù)制代碼代碼如下:

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);

這段代碼其實也沒什么問題，如果把注釋的哪一行的注釋去掉，那么在編譯的時候就直接報錯了，因為編譯器指出它不能發(fā)送值5.0到方法Add(),因為該方法僅接受int型。

不同于ArrayList,這里的代碼實現(xiàn)了類型安全。

CLR對于泛型的支持

泛型不僅是一個語言級上的特征。.NET CLR能識別出泛型。在這種意義上說,泛型的使用是.NET中最為優(yōu)秀的特征之一。對每個用于泛型化的類型的參數(shù)，類也同樣沒有脫離開微軟中間語言(MSIL)。換句話說,你的配件集僅包含你的參數(shù)化的數(shù)據(jù)結(jié)構(gòu)或類的一個定義，而不管使用多少種不同的類型來表達該參數(shù)化的類型。例如,如果你定義一個泛型類型MyList＜T＞，僅僅該類型的一個定義出現(xiàn)在MSIL中。當程序執(zhí)行時,不同的類被動態(tài)地創(chuàng)建,每個類對應(yīng)該參數(shù)化類型的一種類型。如果你使用MyList＜int＞和MyList＜double＞，有兩種類即被創(chuàng)建。

接下來創(chuàng)建一個簡單的泛型類

復(fù)制代碼代碼如下:

public class MyList<T>
    {
        private static int objCount = 0;
        public MyList()
        {
            objCount++;
        }

        public int Count
        {
            get { return objCount; }
        }
    }

該例中，我創(chuàng)建了一個稱為MyList泛型類。為把它參數(shù)化，我簡單地插入了一個尖括號。在＜＞內(nèi)的T代表了實際的當使用該類時要指定的類型。在MyList類中，定義了一個靜態(tài)字段objCount。我在構(gòu)造器中增加它的值。因此我能發(fā)現(xiàn)使用我的類的用戶共創(chuàng)建了多少個那種類型的對象。屬性Count返回與被調(diào)用的實例同類型的實例的數(shù)目。

復(fù)制代碼代碼如下:

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()方法,我創(chuàng)建了MyList＜int＞的兩個實例，一個MyList＜double＞的實例，還有兩個MyList＜SampleClass＞的實例--其中SampleClass是我已定義了的類。問題是:Count(上面的程序的輸出)的值該是多少？在你繼閱讀之前，試一試回答這個問題。

前面兩個2對應(yīng)MyList＜int＞，第一個1對應(yīng)MyList＜double＞，第二個1對應(yīng)MyList＜SampleClass＞--在此，僅創(chuàng)建一個這種類型的實例。最后一個2對應(yīng)MyList＜SampleClass＞，因為代碼中又創(chuàng)建了這種類型的另外一個實例。上面的例子說明MyList＜int＞是一個與MyList＜double＞不同的類，而MyList＜double＞又是一個與MyList＜SampleClass＞不同的類。因此，在這個例中,我們有四個類：MyList: MyList＜T＞，MyList＜int＞，MyList＜double＞和MyList＜X＞。注意，雖然有4個MyList類，但僅有一個被存儲在MSIL。怎么能證明這一點？請看下圖顯示出的使用工具ildasm.exe生成的MSIL代碼。

泛型方法

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

復(fù)制代碼代碼如下:

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()方法就是一個泛型方法，它與參數(shù)化的類型T一起工作。當在Main()中激活Copy()時，編譯器根據(jù)提供給Copy()方法的參數(shù)確定出要使用的具體類型。

約束機制及其優(yōu)點

一個泛型類允許你寫自己的類而不必拘泥于任何類型，但允許你的類的使用者以后可以指定要使用的具體類型。通過對可能會用于參數(shù)化的類型的類型施加約束，這給你的編程帶來很大的靈活性--你可以控制建立你自己的類。讓我們分析一個例子：

復(fù)制代碼代碼如下:

        public static T Max<T>(T op1, T op2) 
        {
            if (op1.CompareTo(op2) < 0)
                 return op1;
            return op2;
        }

編譯代碼將會有一個錯誤。

假定我需要這種類型以支持CompareTo()方法的實現(xiàn)。我能夠通過加以約束--為參數(shù)化類型指定的類型必須要實現(xiàn)IComparable接口--來指定這一點。

復(fù)制代碼代碼如下:

        public static T Max<T>(T op1, T op2)where T:IComparable
        {
            if (op1.CompareTo(op2) < 0)
                 return op1;
            return op2;
        }

好了，我指定的約束是，用于參數(shù)化類型的類型必須繼承自(實現(xiàn))Icomparable。現(xiàn)在可以編譯成功，并且調(diào)用了。

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

　　where T : struct 類型必須是一種值類型(struct)

　　where T : class 類型必須是一種引用類型(class)

　　where T : new() 類型必須有一個無參數(shù)的構(gòu)造器

　　where T : class_name 類型可以是class_name或者是它的一個子類

　　where T : interface_name 類型必須實現(xiàn)指定的接口

　　你可以指定約束的組合，就象: where T : IComparable, new()。這就是說，用于參數(shù)化類型的類型必須實現(xiàn)Icomparable接口并且必須有一個無參構(gòu)造器。

繼承與泛型

一個使用參數(shù)化類型的泛型類，象MyClass1＜T＞，稱作開放結(jié)構(gòu)的泛型。一個不使用參數(shù)化類型的泛型類，象MyClass1＜int＞,稱作封閉結(jié)構(gòu)的泛型。

你可以從一個封閉結(jié)構(gòu)的泛型進行派生；也就是說，你可以從另外一個稱為MyClass1的類派生一個稱為MyClass2的類，就象：

復(fù)制代碼代碼如下: