[.net 面向對象編程基礎] (18) 泛型

[.net 面向對象編程基礎] (18) 泛型

    上一節我們說到了兩種數據類型數組和集合，數組是指包含同一類型的多個元素，集合是指.net中提供數據存儲和檢索的專用類。

    數組使用前需要先指定大小，並且檢索不方便。集合檢索和聲明方便，但是存在類型安全問題，本來使一個類型安全的C#變得不安全了。

    集合為了解決數組預設大小的問題，采取了一種自動擴容的辦法，這樣當大小不夠時，他就創建一個新的存儲區域，把原有集合的元素復制過來。如此又對性能上也是有很大的影響。

    上節我們說到解決這些缺陷的方法，那就是.NET 2.0以后，微軟程序猿們推出來的新特性——泛型。

1.什么是泛型？

泛型是具有占位符（類型參數）的類、結構、接口和方法，這些占位符是類、結構、接口和方法所存儲或使用的一個或多個占位符。

這個概念聽起來比較繞，其實理解起來也不難，我的理解是類、接口、委托、結構或方法中有類型參數就是泛型類型，這樣就有類型參數的概念。泛型集合類可以將類型參數用作它存儲對象的點位符；類型參數作為其字段或方法的參數類型出現（這是MSDN中的描述）。

泛型集合所在的命我空間為：System.Collections.Generic

而List類是ArrayList的泛型等效類。該類使用大小按需動態增加的數組實現IList接口。使用方法就是IList<T>和List<T>,這個T就是你要指定的集合的數據或對象類型。

2.泛型聲明

 泛型類： class Name<t>{}

 泛型方法: void Name(T t){}

 泛型接口：interface IName<T>{}

 泛型結構：struct Name<T>{}

 泛型委托：public delegate void Name<T>(T param);

3.泛型方法

    泛型我們在定義的時候，說明了他是可以使用占位符來占位類、結構、接口和方法的。我們先看一下方法使用泛型的例子。

我們還是使用前面的例子來看一下使用泛型：

類之間的關系UML圖如下：

我們調用假如要實現，讓每個動物都叫幾聲。該如何寫呢？

/// <summary>
/// 動物類(父類 抽象類)
/// </summary>
abstract class Animal
{
    /// <summary>
    /// 名字
    /// 說明：類和子類可訪問
    /// </summary>
    protected string name;

    /// <summary>
    /// 構造函數
    /// </summary>
    /// <param name="name"></param>
    public Animal(string name)
    {
        this.name = name;
    }

    private int shoutNum = 8;
    public int ShoutNum
    {
        get { return shoutNum; }
        set { shoutNum = value; }
    }

    /// <summary>
    /// 名字(虛屬性)
    /// </summary>
    public virtual string MyName
    {
        get { return this.name; }
    }

    /// <summary>
    /// 叫聲，這個方法去掉虛方法，把循環寫在這里
    /// </summary>
    public void Shout()
    {
        string result = "";
        for (int i = 0; i < ShoutNum; i++)
            result += getShoutSound() + "！";

        Console.WriteLine(MyName);
        Console.WriteLine(result);
    }

    /// <summary>
    /// 創建一個叫聲的虛方法，子類重寫
    /// </summary>
    /// <returns></returns>
    public virtual string getShoutSound()
    {
        return "";
    }

    /// <summary>
    /// 讓所有動集合類的動物叫三次並報名字 (泛型)
    /// </summary>
    /// <param name="animal"></param>
    public static void AnimalShout(IList<Animal> animal)
    {
        DateTime dt = System.DateTime.Now;
        foreach (Animal anm in animal)
        {
            anm.Shout();
        }
        Console.WriteLine("使用泛型讓所有動物叫一遍所用時間為：" + (System.DateTime.Now - dt).TotalMilliseconds +"毫秒");
    }
    /// <summary>
    /// 讓所有動集合類的動物叫三次並報名字 (重載方法 集合)
    /// </summary>
    /// <param name="animal"></param>
    public static void AnimalShout(ArrayList animal)
    {
        DateTime dt = System.DateTime.Now;
        foreach (Animal anm in animal)
        {
            anm.Shout();
        }
        Console.WriteLine("使用集合讓所有動物叫一遍所用時間為：" + (System.DateTime.Now - dt).TotalMilliseconds + "毫秒");
    }

    /// <summary>
    /// 讓所有動集合類的動物叫三次並報名字 (重載方法 數組)
    /// </summary>
    /// <param name="animal"></param>
    public static void AnimalShout(Animal[] animal)
    {
        DateTime dt = System.DateTime.Now;
        foreach (Animal anm in animal)
        {
            anm.Shout();
        }
        Console.WriteLine("使用數組讓所有動物叫一遍所用時間為：" + (System.DateTime.Now - dt).TotalMilliseconds + "毫秒");
    }
}


/// <summary>
/// 狗（子類）
/// </summary>
class Dog : Animal
{
    string myName;
    public Dog(string name)
        : base(name)
    {
        myName = name;
    }

    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：狗狗，我叫：" + this.name; }
    }

    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "汪！";
    }
}

/// <summary>
/// 狗（子類）
/// </summary>
class ShepherdDog : Dog
{
    string myName;
    public ShepherdDog(string name)
        : base(name)
    {
        myName = name;
    }

    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：牧羊犬，我叫：" + this.name; }
    }

    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "汪~嗚！";
    }
}

/// <summary>
/// 貓（子類）
/// </summary>
class Cat : Animal
{
    string myName;
    public Cat(string name)
        : base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：貓咪，我叫：" + this.name; }

    }

    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "喵！";
    }
}

/// <summary>
/// 貓（子類）
/// </summary>
class PersianCat : Cat
{
    string myName;
    public PersianCat(string name)
        : base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：波斯貓，我叫：" + this.name; }

    }

    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "喵~嗚！";
    }
}

/// <summary>
/// 羊（子類）
/// </summary>
class Sheep : Animal
{
    string myName;
    public Sheep(string name)
        : base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：羊羊，我叫：" + this.name; }

    }
    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "咩！";
    }
}

調用方法：

//數組
Animal[] animalArray = new Animal[] { new Dog("旺財"), new Cat("小花"), new Cat("阿狸"), new Sheep("純羊"), new Dog("小白"), new ShepherdDog("汪羊"), new PersianCat("機貓") };
    
//泛型          
IList<Animal> animal = new List<Animal>();          
animal.Add(new Dog("旺財"));
animal.Add(new Cat("小花"));
animal.Add(new Cat("阿狸"));
animal.Add(new Sheep("純羊"));
animal.Add(new Dog("小白"));
animal.Add(new ShepherdDog("汪羊"));
animal.Add(new PersianCat("機貓"));

//集合
ArrayList animalArrayList = new ArrayList();          
animalArrayList.Add(new Dog("旺財"));
animalArrayList.Add(new Cat("小花"));
animalArrayList.Add(new Cat("阿狸"));
animalArrayList.Add(new Sheep("純羊"));
animalArrayList.Add(new Dog("小白"));
animalArrayList.Add(new ShepherdDog("汪羊"));
animalArrayList.Add(new PersianCat("機貓"));
          

//調用重載方法看它們的執行叫8次並報名字所需時間
Animal.AnimalShout(animalArray);        
Animal.AnimalShout(animal);              
Animal.AnimalShout(animalArrayList);
Console.ReadLine();

執行結果如下：

 以上的實例並沒有模擬出能客觀測試效率的環境，因為根據我們的經驗數組並不能接受不同類型的元素，而集合和泛型可以，如果使用不同數據測試，也不是客觀的。以上實例主要反映了泛型、數組、集合的使用方法，小伙伴們不要太糾結測試時間，不過泛型的時間確實是比較快的。有了泛型小伙伴們就不要再使用ArrayList這個不安全類型了。

數組、List和ArrayList的區別:

上節說了數組和集合ArrayList的區別，這節我們使用了泛型，再說一下他們三者的區別

數組:
（1）在內存中是連續存儲的，所以它的索引速度是非常的快，而且賦值與修改元素也很簡單。

（2）但是數組也存在一些不足的地方。比如在數組的兩個數據間插入數據也是很麻煩的，還有我們在聲明數組的時候，必須同時指明數組的長度，數組的長度過長，會造成內存浪費，數組和長度過短，會造成數據溢出的錯誤。這樣如果在聲明數組時我們並不清楚數組的長度，就變的很麻煩了.

集合ArrayList:

集合的出現就是為了解決數組的缺陷，但他本身也有缺陷，直到.NET 2.0以后出現泛型，我們可以說這是微軟設計上的失誤。
(1).ArrayList並非類型安全

ArrayList不論什么類型都接受，實際是接受一個object類型。

比如如下操作：

ArrayList ar = new ArrayList();

ar.Add(111);

ar.Add("bbb");

我們使用foreach遍歷的時候   foreach(int array in ar){}那么遇到”bbb”則程度報錯，因此我們說他是非安全類型。

(2).遍歷ArrayList資源消耗大

因此類型的非安全，我們在使用ArrayList的時候，就意味着增加一個元素，就需要值類型轉換為Object對象。遍歷的時候，又需要將Object轉為值類型。

就是裝箱(boxing,指將值類型轉換為引用類型)   和
拆箱（unboxing,指將引用類型轉換為值類型）

由於裝箱了拆箱頻繁進行，需要大量計算，因此開銷很大。

泛型List：

List和AraayList都是繼承於IList,屬於等效類，他們之間的區別也是對集合ArrayList局限性的修改

（1）類型安全，通過允許指定泛型類或方法操作的特定類型，泛型功能將類型安全的任務從您轉移給了編譯器。不需要編寫代碼來檢測數據類型是否正確，因為會在編譯時強制使用正確的數據類型。減少了類型強制轉換的需要和運行時錯誤的可能性。

（2）減少開銷，泛型提供了類型安全但沒有增加多個實現的開銷。

3.泛型類

對於泛型類，我們先解決一下實際例子：假如我們有一個泛型類，不知道是什么類型，在初始化的時候再指定類型。類里面有一個方法，可以接受初始化的參數類型，也就是一個泛型方法。

/// <summary>
/// 泛型有一個泛型方法，該方法有一個泛型參數
/// </summary>
/// <typeparam name="T"></typeparam>
class MyClass<T>
{
    public static T  F(T param)
    {
        return param;
    }
}

調用：

//泛型類調用
int param = 2, param2= 3;
string result1 = (MyClass<string>.F(param.ToString()) + param2).ToString();
string result2 = (MyClass<int>.F(param) + param2).ToString();

Console.WriteLine(result1);
Console.WriteLine(result2);
Console.ReadLine();

可以看到，輸出結果為： 23 和 5 ，使用泛型，我們不會因為數據類型不同，就需要去復制一個方法去處理了。

4.類型約束

我們上面定義了泛型，他們默認沒有類型約束，就是說可以是任意類型。既然定義了泛型，為何還要約束，其實我們這么理解，泛型首先是一種安全類型，約束他只是讓他的范圍更小一點而已。

比如某些情況下，我們需要約束類型

主要有以下六種類型的約束:

約束	說明
T：結構	類型參數必須是值類型。可以指定除 Nullable 以外的任何值類型。有關更多信息，請參見使用可空類型（C# 編程指南）。
T：類	類型參數必須是引用類型，包括任何類、接口、委托或數組類型。
T：new()	類型參數必須具有無參數的公共構造函數。當與其他約束一起使用時，new() 約束必須最后指定。
T：<基類名>	類型參數必須是指定的基類或派生自指定的基類。
T：<接口名稱>	類型參數必須是指定的接口或實現指定的接口。可以指定多個接口約束。約束接口也可以是泛型的。
T：U	為 T 提供的類型參數必須是為 U 提供的參數或派生自為 U 提供的參數。這稱為裸類型約束。

類型約束的特點：

A.指定的就是類型參數必須是引用類型，

B.包括任何類、接口、委托或數組類型，如果除了這幾樣就是非法的了

C.可以輸入任何的引用類型同時也確定了范圍，防止了輸入值類型引發的不安全

D.約束的類型必須是非封閉的類型

E.建議不要對類型參數使用 == 和 != 運算符，因為這些運算符僅測試引用同一性而不測試值相等性

F.如果有new（），則一定要放在最后

未綁定的類型參數

沒有約束的類型參數（如公共類 SampleClass<T>{} 中的 T）稱為未綁定的類型參數。未綁定的類型參數具有以下規則：

·不能使用 != 和 == 運算符，因為無法保證具體類型參數能支持這些運算符。

·可以在它們與 System.Object 之間來回轉換，或將它們顯式轉換為任何接口類型。

·可以將它們與 null 進行比較。將未綁定的參數與 null 進行比較時，如果類型參數為值類型，則該比較將始終返回 false。

裸類型約束

·用作約束的泛型類型參數稱為裸類型約束。

·當具有自己的類型參數的成員函數需要將該參數約束為包含類型的類型參數時，裸類型約束很有用，泛型類的裸類型約束的作用非常有限，因為編譯器除了假設某個裸類型約束派生自 System.Object 以外，不會做其他任何假設。

·在希望強制兩個類型參數之間的繼承關系的情況下，可對泛型類使用裸類型約束。

5.約束舉例說明

下面對這幾種約束舉例說明

還是以這個動物系列為例，下面是實現代碼：

/// <summary>
/// 動物類(父類 抽象類)
/// </summary>
abstract class Animal
{
    /// <summary>
    /// 名字
    /// 說明：類和子類可訪問
    /// </summary>
    protected string name;

    /// <summary>
    /// 構造函數
    /// </summary>
    /// <param name="name"></param>
    public Animal(string name)
    {
        this.name = name;
    }

    private int shoutNum = 3;
    public int ShoutNum
    {
        get { return shoutNum; }
        set { shoutNum = value; }
    }

    /// <summary>
    /// 名字(虛屬性)
    /// </summary>
    public virtual string MyName
    {
        get { return this.name; }
    }

    /// <summary>
    /// 叫聲，這個方法去掉虛方法，把循環寫在這里
    /// </summary>
    public void Shout()
    {
        string result = "";
        for (int i = 0; i < ShoutNum; i++)
            result += getShoutSound() + "！";

        Console.WriteLine(MyName);
        Console.WriteLine(result);
    }

    /// <summary>
    /// 創建一個叫聲的虛方法，子類重寫
    /// </summary>
    /// <returns></returns>
    public virtual string getShoutSound()
    {
        return "";
    }
}

/// <summary>
/// 聲明一個接口 ISpeak(講話)
/// </summary>
interface ISpeak
{
    void Speak();
}

/// <summary>
/// 狗（子類）
/// </summary>
class Dog : Animal
{
    string myName;
    public Dog(string name): base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：狗狗，我叫：" + this.name; }
    }
    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "汪！";
    }
}

/// <summary>
/// 貓（子類）
/// </summary>
class Cat : Animal
{
    string myName;
    public Cat(string name): base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：貓咪，我叫：" + this.name; }
    }
    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "喵！";
    }
}

/// <summary>
/// 藍貓（子類）
/// 繼承 Cat和接口ISpeak
/// </summary>
class BlueCat : Cat,ISpeak
{
    string myName;
    public BlueCat(string name) : base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：藍貓，我叫：" + this.name; }
    }

    /// <summary>
    /// 實現接口ISpeak的成員Speak
    /// </summary>
    public void Speak()
    {
        Console.WriteLine("我會說人話：“你好，我叫:" + this.name + "~~~”");
    }
}

/// <summary>
/// 羊（子類）
/// </summary>
class Sheep : Animal
{
    string myName;
    public Sheep(string name): base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：羊羊，我叫：" + this.name; }
    }
    /// <summary>
    /// 叫（重寫父類方法）
    /// </summary>
    public override string getShoutSound()
    {
        return "咩！";
    }
}

/// <summary>
/// 喜羊羊（子類）
/// 繼承 Sheep和接口ISpeak
/// </summary>
class PleasantSheep : Sheep, ISpeak
{
    string myName;
    public PleasantSheep(string name) : base(name)
    {
        myName = name;
    }
    /// <summary>
    /// 名字(重寫父類屬性)
    /// </summary>
    public override string MyName
    {
        get { return "我是：喜羊羊，我叫：" + this.name; }
    }     
    /// <summary>
    /// 實現接口ISpeak的成員Speak
    /// </summary>
    public void Speak()
    {
        Console.WriteLine("我會說人話：“你好，我叫:" + this.name + "~~~”");
    }
}

5.1基類約束

這個比較常見，就是約束類型的實參都必須繼承同一基類

我們新建一個泛型類CatShout，約束它的基類實參為Cat類 

//泛型約束 - 基類約束
class CatShout<T>
    where T : Cat
{   
    public  void Shout(T cat)
    {
        cat.Shout();
    }
}

 調用及結果：

//泛型約束- 基類約束
CatShout<Cat> cat = new CatShout<Cat>();
cat.Shout(new BlueCat("蘭喵"));
Console.ReadLine();
//CatShout<Dog> dog = new CatShout<Dog>(); 假如使用 Dog類實例化，約束生效，程序報錯

5.2 接口約束

這次我們建立一個泛型類AnimalSpeak類，約束它派生自接口ISpeak 

//泛型約束 - 接口約束
class AnimalSpeak<T>
    where T : ISpeak
{
    public void Speak(T t)
    {
        t.Speak();
    }
}

 調用及結果：

//泛型約束- 接口約束
AnimalSpeak<BlueCat> animalSpeak = new AnimalSpeak<BlueCat>();
animalSpeak.Speak(new BlueCat("蘭喵"));

AnimalSpeak<PleasantSheep> animalSpeak2 = new AnimalSpeak<PleasantSheep>();
animalSpeak2.Speak(new PleasantSheep("肥咩"));

//假如使用以下調用，約束生效,程序報錯，因為Cat並不繼承接口ISpeak,不符合接口約束
//AnimalSpeak<Cat> animalSpeak3 = new AnimalSpeak<Cat>();
//animalSpeak2.Speak(new Cat("阿狸"));

說明：可以同時約束為類和接口，類在前面，接口在后。接口可以有多個，類只能一個，不可以繼承多個類。

 6.0 要點：

最后總結一下

A.泛型基本的使用比較簡單，簡單說就是一個取代數組和集合的安全類型

B.泛型包括，泛型類、方法、接口、委托、結構。

C.泛型在某些情況下為了調用更加安全，即在編譯階段就進行校驗，經常使用約束

D.泛型的類型約束有幾個方面：類約束，接口，構造函數，結構等。基類約束、接口約束和構造函數約束較為常見

E.類的約束使用where關鍵詞，約束的幾個方面有先后順序，通常類，接口，構造函數，這樣的順序。

如果感覺約束這塊兒有點難理解，小伙伴們先掌握好基本泛型使用方法。

 ============================================================================================== 

返回目錄

 <如果對你有幫助，記得點一下推薦哦，有不明白的地方或寫的不對的地方，請多交流> 

==============================================================================================