c#泛型學(xué)習(xí)詳解 創(chuàng)建線性鏈表
術(shù)語表
generics:泛型
type-safe:類型安全
collection: 集合
compiler:編譯器
run time:程序運(yùn)行時
object: 對象
.NET library:.Net類庫
value type: 值類型
box: 裝箱
unbox: 拆箱
implicity: 隱式
explicity: 顯式
linked list: 線性鏈表
node: 結(jié)點(diǎn)
indexer: 索引器
泛型是什么?
很多人覺得泛型很難理解。我相信這是因?yàn)樗麄兺ǔT诹私夥盒褪怯脕斫鉀Q什么問題之前,就被灌輸了大量的理論和范例。結(jié)果就是你有了一個解決方案,但是卻沒有需要使用這個解決方案的問題。
這篇文章將嘗試著改變這種學(xué)習(xí)流程,我們將以一個簡單的問題作為開始:泛型是用來做什么的?答案是:沒有泛型,將會很難創(chuàng)建類型安全的集合。
C# 是一個類型安全的語言,類型安全允許編譯器(可信賴地)捕獲潛在的錯誤,而不是在程序運(yùn)行時才發(fā)現(xiàn)(不可信賴地!)。因 此,在C#中,所有的變量都有一個定義了的類型;當(dāng)你將一個對象賦值給那個變量的時候,編譯器檢查這個賦值是否正確,如果有問題,將會給出錯誤信息。
在 .Net 1.1 版本(2003)中,當(dāng)你在使用集合時,這種類型安全就失效了。由.Net 類庫提供的所有關(guān)于集合的類全是用來存儲基類型(Object)的,而.Net中所有的一切都是由Object基類繼承下來的,因此所有類型都可以放到一 個集合中。于是,相當(dāng)于根本就沒有了類型檢測。
更糟的是,每一次你從集合中取出一個Object,你都必須將它強(qiáng)制轉(zhuǎn)換成正確的類型,這一轉(zhuǎn)換將對性能造成影響,并且產(chǎn)生冗長的代碼(如果你忘了 進(jìn)行轉(zhuǎn)換,將會拋出異常)。更進(jìn)一步地講,如果你給集合中添加一個值類型(比如,一個整型變量),這個整型變量就被隱式地裝箱了(再一次降低了性能),而 當(dāng)你從集合中取出它的時候,又會進(jìn)行一次顯式地拆箱(又一次性能的降低和類型轉(zhuǎn)換)。
關(guān)于裝箱、拆箱的更多內(nèi)容,請?jiān)L問 陷阱4,警惕隱式的裝箱、拆箱。
創(chuàng)建一個簡單的線性鏈表
為了生動地感受一下這些問題,我們將創(chuàng)建一個盡可能簡單的線性鏈表。對于閱讀本文的那些從未創(chuàng)建過線性鏈表的人。你可以將線性鏈表想像成有一條鏈子 栓在一起的盒子(稱作一個結(jié)點(diǎn)),每個盒子里包含一些數(shù)據(jù) 和 鏈接到這個鏈子上的下一個盒子的引用(當(dāng)然,除了最后一個盒子,這個盒子對于下一個盒子的引用被設(shè)置成NULL)。
為了創(chuàng)建我們的簡單線性鏈表,我們需要下面三個類:
1、Node 類,包含數(shù)據(jù)以及下一個Node的引用。
2、LinkedList 類,包含鏈表中的第一個Node,以及關(guān)于鏈表的任何附加信息。
3、測試程序,用于測試 LinkedList 類。
為了查看鏈接表如何運(yùn)作,我們添加Objects的兩種類型到鏈表中:整型 和 Employee類型。你可以將Employee類型想象成一個包含關(guān)于公司中某一個員工所有信息的類。出于演示的目的,Employee類非常的簡單。
public class Employee{
private string name;
public Employee (string name){
this.name = name;
}
public override string ToString(){
return this.name;
}
}
這個類僅包含一個表示員工名字的字符串類型,一個設(shè)置員工名字的構(gòu)造函數(shù),一個返回Employee名字的ToString()方法。
鏈接表本身是由很多的Node構(gòu)成,這些Note,如上面所說,必須包含數(shù)據(jù)(整型 和 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; }
}
}
注意構(gòu)造函數(shù)將私有的數(shù)據(jù)成員設(shè)置成傳遞進(jìn)來的對象,并且將 next 字段設(shè)置成null。
這個類還包括一個方法,Append,這個方法接受一個Node類型的參數(shù),我們將把傳遞進(jìn)來的Node添加到列表中的最后位置。這過程是這樣的: 首先檢測當(dāng)前Node的next字段,看它是不是null。如果是,那么當(dāng)前Node就是最后一個Node,我們將當(dāng)前Node的next屬性指向傳遞進(jìn) 來的新結(jié)點(diǎn),這樣,我們就把新Node到了鏈表的尾部。
如果當(dāng)前Node的next字段不是null,說明當(dāng)前node不是鏈表中的最后一個node。因?yàn)閚ext字段的類型也是node,所以我們調(diào)用next字段的Append方法(注:遞歸調(diào)用),再一次傳遞Node參數(shù),這樣繼續(xù)下去,直到找到最后一個Node為止。
public void Append(Node newNode){
if ( this.next == null ){
this.next = newNode;
}else{
next.Append(newNode);
}
}
Node 類中的 ToString() 方法也被覆蓋了,用于輸出 data 中的值,并且調(diào)用下一個 Node 的 ToString()方法(譯注:再一次遞歸調(diào)用)。
public override string ToString(){
string output = data.ToString();
if ( next != null ){
output += ", " + next.ToString();
}
return output;
}
這樣,當(dāng)你調(diào)用第一個Node的ToString()方法時,將打印出所有鏈表上Node的值。
LinkedList 類本身只包含對一個Node的引用,這個Node稱作 HeadNode,是鏈表中的第一個Node,初始化為null。
public class LinkedList{
Node headNode = null;
}
LinkedList 類不需要構(gòu)造函數(shù)(使用編譯器創(chuàng)建的默認(rèn)構(gòu)造函數(shù)),但是我們需要創(chuàng)建一個公共方法,Add(),這個方法把 data存儲到線性鏈表中。這個方法首先檢查headNode是不是null,如果是,它將使用data創(chuàng)建結(jié)點(diǎn),并將這個結(jié)點(diǎn)作為headNode,如 果不是null,它將創(chuàng)建一個新的包含data的結(jié)點(diǎn),并調(diào)用headNode的Append方法,如下面的代碼所示:
public void Add(Object data){
if ( headNode == null ){
headNode = new Node(data);
}else{
headNode.Append(new Node(data));
}
}
為了提供一點(diǎn)集合的感覺,我們?yōu)榫€性鏈表創(chuàng)建一個索引器。
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()方法再一次被覆蓋,用以調(diào)用headNode的ToString()方法。
public override string ToString(){
if ( this.headNode != null ){
return this.headNode.ToString();
}else{
return string.Empty;
}
}
測試線性鏈表
我們可以添加一些整型值到鏈表中進(jìn)行測試:
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...");
}
如果你對這段代碼進(jìn)行測試,它會如預(yù)計(jì)的那樣工作:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Done. Adding employees...
然而,因?yàn)檫@是一個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.");
輸出的結(jié)果證實(shí)了,整型值和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.
雖然看上去這樣很方便,但是負(fù)面影響是,你失去了所有類型安全的特性。因?yàn)榫€性鏈表需要的是一個Object類型,每一個添加到集合中的整型值都被隱式裝箱了,如同 IL 代碼所示:
IL_000c: box [mscorlib]System.Int32
IL_0011: callvirt instance void ObjectLinkedList.LinkedList::Add(object)
同樣,如果上面所說,當(dāng)你從你的列表中取出項(xiàng)目的時候,這些整型必須被顯式地拆箱(強(qiáng)制轉(zhuǎn)換成整型),Employee類型必須被強(qiáng)制轉(zhuǎn)換成 Employee類型。
Console.WriteLine("The fourth integer is " + Convert.ToInt32(ll[3]));
Employee d = (Employee) ll[11];
Console.WriteLine("The second Employee is " + d);
這些問題的解決方案是創(chuàng)建一個類型安全的集合。一個 Employee 線性鏈表將不能接受 Object 類型;它只接受 Employee類的實(shí)例(或者繼承自Employee類的實(shí)例)。這樣將會是類型安全的,并且不再需要類型轉(zhuǎn)換。一個 整型的 線性鏈表,這個鏈表將不再需要裝箱和拆箱的操作(因?yàn)樗荒芙邮苷椭?。
作為示例,你將創(chuàng)建一個 EmployeeNode,該結(jié)點(diǎn)知道它的data的類型是Employee。
public class EmployeeNode {
Employee employeedata;
EmployeeNode employeeNext;
}
Append 方法現(xiàn)在接受一個 EmployeeNode 類型的參數(shù)。你同樣需要創(chuàng)建一個新的 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 類型,等等。這樣確實(shí)解決了裝箱、拆箱的問題,并且加入了類型安全的特性。你現(xiàn)在可以添加Employee(但不是整型)到你新的線性鏈表中了,并且當(dāng)你從中取出Employee的時候,不再需要類型轉(zhuǎn)換了。
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);
這樣多好啊,當(dāng)有一個整型試圖隱式地轉(zhuǎn)換到Employee類型時,代碼甚至連編譯器都不能通過!
但它不好的地方是:每次你需要創(chuàng)建一個類型安全的列表時,你都需要做很多的復(fù)制/粘貼 。一點(diǎn)也不夠好,一點(diǎn)也沒有代碼重用。同時,如果你是這個類的作者,你甚至不能提前欲知這個鏈接列表所應(yīng)該接受的類型是什么,所以,你不得不將添加類型安 全這一機(jī)制的工作交給類的使用者---你的用戶。
使用泛型來達(dá)到代碼重用
解決方案,如同你所猜想的那樣,就是使用泛型。通過泛型,你重新獲得了鏈接列表的 代碼通用(對于所有類型只用實(shí)現(xiàn)一次),而當(dāng)你初始化鏈表的時候你告訴鏈表所能接受的類型。這個實(shí)現(xiàn)是非常簡單的,讓我們重新回到Node類:
public class Node{
Object data;
...
注意到 data 的類型是Object,(在EmployeeNode中,它是Employee)。我們將把它變成一個泛型(通常,由一個大寫的T代表)。我們同樣定義Node類,表示它可以被泛型化,以接受一個T類型。
public class Node <T>{
T data;
...
讀作:T類型的Node。T代表了當(dāng)Node被初始化時,Node所接受的類型。T可以是Object,也可能是整型或者是Employee。這個在Node被初始化的時候才能確定。
注意:使用T作為標(biāo)識只是一種約定俗成,你可以使用其他的字母組合來代替,比如這樣:
public class Node <UnknownType>{
UnknownType data;
...
通過使用T作為未知類型,next字段(下一個結(jié)點(diǎn)的引用)必須被聲明為T類型的Node(意思是說接受一個T類型的泛型化Node)。
Node<T> next;
構(gòu)造函數(shù)接受一個T類型的簡單參數(shù):
public Node(T data)
{
this.data = data;
this.next = null;
}
Node 類的其余部分是很簡單的,所有你需要使用Object的地方,你現(xiàn)在都需要使用T。LinkedList 類現(xiàn)在接受一個 T類型的Node,而不是一個簡單的Node作為頭結(jié)點(diǎn)。
public class LinkedList<T>{
Node<T> headNode = null;
再來一遍,轉(zhuǎn)換是很直白的。任何地方你需要使用Object的,現(xiàn)在改做T,任何需要使用Node的地方,現(xiàn)在改做 Node<T>。下面的代碼初始化了兩個鏈接表。一個是整型的。
LinkedList<int> ll = new LinkedList<int>();
另一個是Employee類型的:
LinkedList<Employee> employees = new LinkedList<Employee>();
剩下的代碼與第一個版本沒有區(qū)別,除了沒有裝箱、拆箱,而且也不可能將錯誤的類型保存到集合中。
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);
泛型允許你不用復(fù)制/粘貼冗長的代碼就實(shí)現(xiàn)類型安全的集合。而且,因?yàn)榉盒褪窃谶\(yùn)行時才被擴(kuò)展成特殊類型。Just In Time編譯器可以在不同的實(shí)例之間共享代碼,最后,它顯著地減少了你需要編寫的代碼。
相關(guān)文章
Winform實(shí)現(xiàn)抓取web頁面內(nèi)容的方法
這篇文章主要介紹了Winform實(shí)現(xiàn)抓取web頁面內(nèi)容的方法,代碼只有短短幾行,但是功能很實(shí)用,需要的朋友可以參考下2014-09-09當(dāng)用戶退出點(diǎn)擊瀏覽器后退仍可回到原來頁面的解決方案
這篇文章主要介紹了當(dāng)用戶退出點(diǎn)擊瀏覽器后退仍可回到原來頁面的解決方案 的相關(guān)資料,需要的朋友可以參考下2016-03-03C#調(diào)用Python程序傳參數(shù)獲得返回值
C# 調(diào)用 Python 程序有多種方式,本文主要介紹了4種方式,文中通過示例代碼介紹的非常詳細(xì),具有一定的參考價值,感興趣的小伙伴們可以參考一下2022-02-02C#操作數(shù)據(jù)庫總結(jié)(vs2005+sql2005)
C#操作數(shù)據(jù)庫總結(jié),每次做項(xiàng)目都會用到數(shù)據(jù)庫,對數(shù)據(jù)庫的操作都是糊里糊涂從書里找代碼用。通過昨天晚上與今天早上的努力,把數(shù)據(jù)庫的操作整理了一下,下面把整理結(jié)果做個小結(jié)2012-09-09.net實(shí)現(xiàn)序列化與反序列化實(shí)例解析
這篇文章主要介紹了.net實(shí)現(xiàn)序列化與反序列化實(shí)例解析,需要的朋友可以參考下2014-08-08C#使用SqlSugarClient進(jìn)行數(shù)據(jù)訪問并實(shí)現(xiàn)了統(tǒng)一的批量依賴注入(示例代碼)
M為 BaseDto 請用C# 給出一個案例,支持不同表對應(yīng)不同的業(yè)務(wù)邏輯層,然后不同倉儲實(shí)例,不同表的業(yè)務(wù),都實(shí)現(xiàn)統(tǒng)一的批量依賴注入,下面通過示例給大家演示如何使用SqlSugarClient進(jìn)行數(shù)據(jù)訪問,并實(shí)現(xiàn)了統(tǒng)一的批量依賴注入,感興趣的朋友跟隨小編一起看看吧2024-05-05