【轉載】C# 理解泛型

術語表

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編譯器可以在不同的實例之間共享代碼，最后，它顯著地減少了你需要編寫的代碼。

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

【轉自】http://www.cnblogs.com/JimmyZhang/archive/2007/08/04/842663.html

轉載于:https://www.cnblogs.com/bad-man/p/7908007.html