C# 理解泛型

來源:互聯網
上載者:User

標籤:

 

出處:http://www.ondotnet.com/pub/a/dotnet/2004/05/17/liberty.html

術語表

generics:泛型
type-safe:型別安全
collection: 集合
compiler:編譯器
run time:程式運行時
object: 對象
.NET library:.Net類庫
value type: 實值型別
box: 裝箱
unbox: 拆箱
implicity: 隱式
explicity: 顯式
linked list: 線性鏈表
node: 結點
indexer: 索引器

簡介

Visual C# 2.0 的一個最受期待的(或許也是最讓人畏懼)的一個特性就是對於泛型的支援。這篇文章將告訴你泛型用來解決什麼樣的問題,以及如何使用它們來提高你的代碼品質,還有你不必恐懼泛型的原因。

泛型是什嗎?

很多人覺得泛型很難理解。我相信這是因為他們通常在瞭解泛型是用來解決什麼問題之前,就被灌輸了大量的理論和範例。結果就是你有了一個解決方案,但是卻沒有需要使用這個解決方案的問題。

這篇文章將嘗試著改變這種學習流程,我們將以一個簡單的問題作為開始:泛型是用來做什麼的?答案是:沒有泛型,將會很難建立型別安全的集合。

C# 是一個型別安全的語言,型別安全允許編譯器(可信賴地)捕獲潛在的錯誤,而不是在程式運行時才發現(不可信賴地,往往發生在你將產品出售了以後!)。因此,在C#中,所有的變數都有一個定義了的類型;當你將一個對象賦值給那個變數的時候,編譯器檢查這個賦值是否正確,如果有問題,將會給出錯誤資訊。

在 .Net 1.1 版本(2003)中,當你在使用集合時,這種型別安全就失效了。由.Net 類庫提供的所有關於集合的類全是用來儲存基底類型(Object)的,而.Net中所有的一切都是由Object基類繼承下來的,因此所有類型都可以放到一個集合中。於是,相當於根本就沒有了類型檢測。

更糟的是,每一次你從集合中取出一個Object,你都必須將它強制轉換成正確的類型,這一轉換將對效能造成影響,並且產生冗長的代碼(如果你忘了進行轉換,將會拋出異常)。更進一步地講,如果你給集合中添加一個實值型別(比如,一個整型變數),這個整型變數就被隱式地裝箱了(再一次降低了效能),而當你從集合中取出它的時候,又會進行一次顯式地拆箱(又一次效能的降低和類型轉換)。

關於裝箱、拆箱的更多內容,請訪問 陷阱4,警惕隱式的裝箱、拆箱。

建立一個簡單的線性鏈表

為了生動地感受一下這些問題,我們將建立一個儘可能簡單的線性鏈表。對於閱讀本文的那些從未建立過線性鏈表的人。你可以將線性鏈表想像成有一條鏈子栓在一起的盒子(稱作一個結點),每個盒子裡包含著一些資料 和 連結到這個鏈子上的下一個盒子的引用(當然,除了最後一個盒子,這個盒子對於下一個盒子的引用被設定成NULL)。

為了建立我們的簡單線性鏈表,我們需要下面三個類:

1、Node 類,包含資料以及下一個Node的引用。

2、LinkedList 類,包含鏈表中的第一個Node,以及關於鏈表的任何附加資訊。

3、測試程式,用於測試 LinkedList 類。

為了查看連結資料表如何運作,我們添加Objects的兩種類型到鏈表中:整型 和 Employee類型。你可以將Employee類型想象成一個包含關於公司中某一個員工所有資訊的類。出於示範的目的,Employee類非常的簡單。

public class Employee{
  private string name;
  public Employee (string name){
    this.name = name;
  }

  public override string ToString(){
   return this.name;
  }
}

這個類僅包含一個表示員工名字的字串類型,一個設定員工名字的建構函式,一個返回Employee名字的ToString()方法。

連結資料表本身是由很多的Node構成,這些Note,如上面所說,必須包含資料(整型 和 Employee)和鏈表中下一個Node的引用。

public class Node{
    Object data;
    Node next;

    public Node(Object data){
       this.data = data;
       this.next = null;
    }

    public Object Data{ 
       get { return this.data; }
       set { data = value; }
    }

    public Node Next{
        get { return this.next; }
       set { this.next = value; }
    }
}

注意建構函式將私人的資料成員設定成傳遞進來的對象,並且將 next 欄位設定成null。

這個類還包括一個方法,Append,這個方法接受一個Node類型的參數,我們將把傳遞進來的Node添加到列表中的最後位置。這過程是這樣的:首先檢測當前Node的next欄位,看它是不是null。如果是,那麼當前Node就是最後一個Node,我們將當前Node的next屬性指向傳遞進來的新結點,這樣,我們就把新Node插入到了鏈表的尾部。

如果當前Node的next欄位不是null,說明當前node不是鏈表中的最後一個node。因為next欄位的類型也是node,所以我們調用next欄位的Append方法(註:遞迴調用),再一次傳遞Node參數,這樣繼續下去,直到找到最後一個Node為止。

public void Append(Node newNode){
    if ( this.next == null ){
       this.next = newNode;
    }else{
       next.Append(newNode);
    }
}

Node 類中的 ToString() 方法也被覆蓋了,用於輸出 data 中的值,並且調用下一個 Node 的 ToString()方法(譯註:再一次遞迴調用)。

public override string ToString(){
    string output = data.ToString();

    if ( next != null ){
       output += ", " + next.ToString();
    }

    return output;
}

這樣,當你調用第一個Node的ToString()方法時,將列印出所有鏈表上Node的值。

LinkedList 類本身只包含對一個Node的引用,這個Node稱作 HeadNode,是鏈表中的第一個Node,初始化為null。

public class LinkedList{
    Node headNode = null;
}

LinkedList 類不需要建構函式(使用編譯器建立的預設建構函式),但是我們需要建立一個公用方法,Add(),這個方法把 data儲存到線性鏈表中。這個方法首先檢查headNode是不是null,如果是,它將使用data建立結點,並將這個結點作為headNode,如果不是null,它將建立一個新的包含data的結點,並調用headNode的Append方法,如下面的代碼所示:

public void Add(Object data){
    if ( headNode == null ){
       headNode = new Node(data);
    }else{
       headNode.Append(new Node(data));
    }
}

為了提供一點集合的感覺,我們為線性鏈表建立一個索引器。

public object this[ int index ]{
    get{
       int ctr = 0;
       Node node = headNode;
       while ( node != null  && ctr <= index ){
           if ( ctr == index ){
              return node.Data;
           }else{
              node = node.Next;
           }
           ctr++;
        }
    return null;
    }
}

最後,ToString()方法再一次被覆蓋,用以調用headNode的ToString()方法。

public override string ToString(){
    if ( this.headNode != null ){
       return this.headNode.ToString();
    }else{
       return string.Empty;
    }
}

測試線性鏈表

我們可以添加一些整型值到鏈表中進行測試:

public void Run(){
    LinkedList ll = new LinkedList();
    for ( int i = 0; i < 10; i ++ ){
       ll.Add(i);
    }

    Console.WriteLine(ll);
    Console.WriteLine("  Done. Adding employees...");
}

如果你對這段代碼進行測試,它會如預計的那樣工作:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Done. Adding employees...

然而,因為這是一個Object類型的集合,所以你同樣可以將Employee類型添加到集合中。

ll.Add(new Employee("John"));
ll.Add(new Employee("Paul"));
ll.Add(new Employee("George"));
ll.Add(new Employee("Ringo"));

Console.WriteLine(ll);
Console.WriteLine("  Done.");

輸出的結果證實了,整型值和Employee類型都被儲存在了同一個集合中。

0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  Done. Adding employees...
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, John, Paul, George, Ringo
Done.

雖然看上去這樣很方便,但是負面影響是,你失去了所有型別安全的特性。因為線性鏈表需要的是一個Object類型,每一個添加到集合中的整型值都被隱式裝箱了,如同 IL 代碼所示:

IL_000c:  box        [mscorlib]System.Int32
IL_0011:  callvirt   instance void ObjectLinkedList.LinkedList::Add(object)

同樣,如果上面所說,當你從你的列表中取出項目的時候,這些整型必須被顯式地拆箱(強制轉換成整型),Employee類型必須被強制轉換成 Employee類型。

Console.WriteLine("The fourth integer is " + Convert.ToInt32(ll[3]));
Employee d = (Employee) ll[11];
Console.WriteLine("The second Employee is " + d);

這些問題的解決方案是建立一個型別安全的集合。一個 Employee 線性鏈表將不能接受 Object 類型;它只接受 Employee類的執行個體(或者繼承自Employee類的執行個體)。這樣將會是型別安全的,並且不再需要類型轉換。一個 整型的 線性鏈表,這個鏈表將不再需要裝箱和拆箱的操作(因為它只能接受整型值)。

作為樣本,你將建立一個 EmployeeNode,該結點知道它的data的類型是Employee。

public class EmployeeNode {
    Employee employeedata;
    EmployeeNode employeeNext;
}

Append 方法現在接受一個 EmployeeNode 類型的參數。你同樣需要建立一個新的 EmployeeLinkedList ,這個鏈表接受一個新的 EmployeeNode:

public class EmployeeLinkedList{
    EmployeeNode headNode = null;
}

EmployeeLinkedList.Add()方法不再接受一個 Object,而是接受一個Employee:

public void Add(Employee data){
    if ( headNode == null ){
       headNode = new EmployeeNode(data);}
    else{
       headNode.Append(new EmployeeNode(data));
    }
}

類似的,索引器必須被修改成接受 EmployeeNode 類型,等等。這樣確實解決了裝箱、拆箱的問題,並且加入了型別安全的特性。你現在可以添加Employee(但不是整型)到你新的線性鏈表中了,並且當你從中取出Employee的時候,不再需要類型轉換了。

EmployeeLinkedList employees = new EmployeeLinkedList();
employees.Add(new Employee("Stephen King"));
employees.Add(new Employee("James Joyce"));
employees.Add(new Employee("William Faulkner"));
/* employees.Add(5);  // try to add an integer - won‘t compile */
Console.WriteLine(employees);
Employee e = employees[1];
Console.WriteLine("The second Employee is " + e);

這樣多好啊,當有一個整型試圖隱式地轉換到Employee類型時,代碼甚至連編譯器都不能通過!

但它不好的地方是:每次你需要建立一個型別安全的列表時,你都需要做很多的複製/粘貼 。一點也不夠好,一點也沒有代碼重用。同時,如果你是這個類的作者,你甚至不能提前欲知這個連結清單所應該接受的類型是什麼,所以,你不得不將添加型別安全這一機制的工作交給類的使用者---你的使用者。

使用泛型來達到代碼重用

解決方案,如同你所猜想的那樣,就是使用泛型。通過泛型,你重新獲得了連結清單的   代碼通用(對於所有類型只用實現一次),而當你初始化鏈表的時候你告訴鏈表所能接受的類型。這個實現是非常簡單的,讓我們重新回到Node類:

public class Node{
    Object data;
    ...

注意到 data 的類型是Object,(在EmployeeNode中,它是Employee)。我們將把它變成一個泛型(通常,由一個大寫的T代表)。我們同樣定義Node類,表示它可以被泛型化,以接受一個T類型。

public class Node <T>{
    T data;
    ...

讀作:T類型的Node。T代表了當Node被初始化時,Node所接受的類型。T可以是Object,也可能是整型或者是Employee。這個在Node被初始化的時候才能確定。

注意:使用T作為標識只是一種約定俗成,你可以使用其他的字母組合來代替,比如這樣:

public class Node <UnknownType>{
    UnknownType data;
    ...

通過使用T作為未知類型,next欄位(下一個結點的引用)必須被聲明為T類型的Node(意思是說接受一個T類型的泛型化Node)。

    Node<T> next;

建構函式接受一個T類型的簡單參數:

public Node(T data)
{
    this.data = data;
    this.next = null;
}

Node 類的其餘部分是很簡單的,所有你需要使用Object的地方,你現在都需要使用T。LinkedList 類現在接受一個 T類型的Node,而不是一個簡單的Node作為頭結點。

public class LinkedList<T>{
    Node<T> headNode = null;

再來一遍,轉換是很直白的。任何地方你需要使用Object的,現在改做T,任何需要使用Node的地方,現在改做 Node<T>。下面的代碼初始化了兩個連結資料表。一個是整型的。

LinkedList<int> ll = new LinkedList<int>();

另一個是Employee類型的:

LinkedList<Employee> employees = new LinkedList<Employee>();

剩下的代碼與第一個版本沒有區別,除了沒有裝箱、拆箱,而且也不可能將錯誤的類型儲存到集合中。

LinkedList<int> ll = new LinkedList<int>();
for ( int i = 0; i < 10; i ++ )
{
    ll.Add(i);
}

Console.WriteLine(ll);
Console.WriteLine("  Done.");

LinkedList<Employee> employees = new LinkedList<Employee>();
employees.Add(new Employee("John"));
employees.Add(new Employee("Paul"));
employees.Add(new Employee("George"));
employees.Add(new Employee("Ringo"));

Console.WriteLine(employees); 
Console.WriteLine("  Done.");
Console.WriteLine("The fourth integer is " + ll[3]);
Employee d = employees[1];
Console.WriteLine("The second Employee is " + d);

泛型允許你不用複製/粘貼冗長的代碼就實作類別型安全的集合。而且,因為泛型是在運行時才被擴充成特殊類型。Just In Time編譯器可以在不同的執行個體之間共用代碼,最後,它顯著地減少了你需要編寫的代碼。

C# 理解泛型

相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.