类型参数化-泛型
中間因為比較忙，空了那么多天，都感覺有點罪過了。話不多說，這一篇主要是要講C#2.0提出的一個新特性，那就是泛型。（現在都C#6.0了。囧囧）
1、什么是泛型？
C#1.0中的委托特性使方法可作為其他方法的參數來傳遞，而C#2.0中提出的泛型特性則使類型可以被參數化，從而不必再為不同的類型提供特殊版本的方法實現。從字面上來的意思來講，泛型代表的就是“通用類型”,它可以代替任意的數據類型，使類型參數化，從而達到只實現一個方法就可以操作多種數據類型的目的，將實現行為與方法操作的數據類型分離，實現了代碼的重用。下面通過.NET類庫中的泛型來說明到底什么是泛型。
clas program
{
static void Main(string[] args)
{
//用int作為實際參數來初始化泛型類型
List<int> intList=new List<int>();
//從int列表添加元素3
intList.Add(3);
//用string作為實際參數來初始化泛型類型
List<string> stringList=new List<string>();
//從string列表添加元素
stringList.Add("learninghard");
}
}
在以上代碼中，List<T>是.NET類庫中實現的泛型參數，T是泛型參數，可以理解為形參。如果想實例化一個泛型類型，必須傳入實際的類型參數，如上面代碼中的int和string，就是實際的額類型參數。同時你也可以自己實現泛型類型，下面會介紹泛型類型的實現方法。
?
2、C# 2.0為什么要引入泛型？
這個就需要用代碼來解釋了。
public class Compare
{
//比較兩個整數大小的方法，方法返回較大的那個整數
public static int compareInt(int i1,int i2)
{
if(i1.CompareTo(i2)>0)
{
return i1;
}
else
{
return i2;
}
}
}
以上的代碼實現對于int類型數據來說完全是沒有問題的，但是當客戶說我想實現兩個字符串大小的比較，你就必須再添加一個比較字符串的大小了。如果客戶說還想添加一個比較浮點數的大小，那你肯定又只能添加一個方法啦。顯然，這種方式是一種比較low的方式，其實方法的代碼都非常的相似，所以我們完全可以只定義一個比較方法就能比較所有不同類型的大小。
這時，泛型就派上用場了，就是為這種情況而生，所以，微軟就在C#2.0中提出了泛型的特性。
//Compare<T>為泛型類，T為類型參數
public class Compare<T> where T:IComparable
{
//使用泛型實現的比較方法
public static T compareGeneric(T t1,T t2)
{
if(t1.CompareTo(t2)>0)
{
return t1;
}
else
{
return t2;
}
}
}
在以上的代碼中，我們實現了一個自定義的泛型類，其中T是泛型的類型參數，compareGeneric是實現的泛型方法，代碼中的where語句是類型參數的約束，它用來使類型參數可以適用于CompareTo方法。有了泛型之后，就不需要針對每種數據類型重復實現相似的比較方法了。
class Program
{
static void Main(string[] args)
{
//調用泛型方法
Console.WriteLine(Compare<int>.compareGeneric(3,4));
Console.WriteLine(Compare<string>.compareGeneric("abc","a"));
Console.ReadKey();
}
}
泛型除了可以實現代碼重用外，還提供了更好的性能和類型安全特性。
?
3、全面解析泛型
3.1 類型參數
在前面的泛型代碼中，就是類型參數。無論調用類型方法還是初始化泛型實例，都需要用真實類型來代替T，可以把T理解為類型的一個占位符，即告訴編譯器，在調用泛型時必須為其指定一個實際類型。
根據泛型類型參數是否提供實際類型，又可把泛型分為兩類：未綁定的泛型和已構造的泛型。如果沒有為類型參數提供實際類型，此時的泛型稱為未綁定的泛型；而如果已指定了實際類型作為參數，則此時的泛型稱為已構造的泛型。
已構造泛型又可分為開放類型和密封類型。其中，開放類型是指包含類型參數的泛型，所有未綁定的泛型類型都屬于開放類型；而封閉類型則是指那些已經為每一個類型參數都傳遞了實際數據類型的泛型。
用以下代碼可以判斷泛型類型是開放還是封閉的。
public class DictionaryStringKey<T>:Dictionary<string,T>{}
class Program
{
static void Main(string[] args)
{
//Dictionary<,>是一個開放類型，它有兩個類型參數
Type t=typeof(Dictionary<,>);
Console.WriteLine("是否為開放類型："+t.ContainsGenericParameters);
//DictionaryStringKey<>也是一個開放類型，但它只有一個類型參數
t=typeof(DictionaryStringKey<>);
Console.WriteLine("是否為開放類型："+t.ContainGenericParameters);
//DictionaryStringKey<int>
t=typeof(DictionaryStringKey<int>);
Console.WriteLine("是否為開放類型："+t.ContainGnericParameters);
}
}
?
3.2 泛型中的靜態字段和靜態函數問題
每個封閉的泛型類型中都有僅屬于它自己的靜態數據。
//泛型類型，具有一個類型參數
public static class TypeWithStaticField<T>
{
//靜態字段
public static string field;
//靜態構造函數
public static void OutField()
{
Console.WirteLine(field+":"+typeof(T).Name);
}
}
//非泛型類
public static class NoGenericTypeWithStaticField
{
public static string field;
public static void OutField()
{
Console.WriteLine(field);
}
}
class Program
{
static void Main(string[] args)
{
//使用不同類型實參來實例化泛型實例
TypeWithStaticField<int>.field="一";
TypeWithStaticField<string>.field="一";
TypeWithStaticField<Guid>.field="一";
?
//對于非泛型類型，此時field只會一個值，每次賦值都改變了原來的值
NoGenericTypeWithStaticField.field="非泛型類靜態字段一";
NoGenericTypeWithStaticField.field="非泛型類靜態字段二";
NoGenericTypeWithStaticField.field="非泛型類靜態字段三";
?
NoGenericTypeWithStaticField.OutField();
TypeWithStaticField<int>.OutField();
TypeWithStaticField<string>.OutField();
TypeWithStaticField<Guid>.OutField();
Console.ReadKey();
}
}
結果如下：
從圖中結果可以看出，每個封閉的泛型類型都有屬于它的靜態字段。這是因為，在使用實際類型參數代替泛型參數時，編譯器會根據不同的類型實參，重新生成類型。
對于編譯器來說，每個封閉泛型類型都是一個不一樣的類型，所以它們都有屬于它自己的靜態字段。靜態構造函數也一樣，每個封閉的泛型類型都有一個靜態構造函數。
?
3.3 類型參數的推斷
class Program
{
static void Main(string[] args)
{
int n1=1;
int n2=2;
genericMethod(ref n1,ref n2);
Console.WriteLine("n1的值現在為："+n1);
Console.WriteLine("n2的值現在為："+n2);
}
?
//泛型方法
private static void genericMethod<T>(ref T t1,ref T t2)
{
T temp=t1;
t1=t2;
t2=temp;
}
}
在以上的代碼中，編譯器會根據傳遞的方法實參來判斷傳入的實際類型參數。如果編譯器根據傳入的參數不能推斷出實際參數類型，就會出現編譯時錯誤。
注意：類型推斷只能用于泛型方法，它對泛型類則并不適用，因為編譯器不能通過泛型類的構造函數推斷出實際的類型參數。
?
3.4 類型參數的約束
不知大家是否注意過，前面的代碼中曾經出現過where T：IComparable的代碼，這個where語句用來使類型參數繼承于IComparable接口，從而對類型參數進行約束。
前面的比大小中，如果沒有進行約束，代碼編譯的時候就會出現錯誤，編譯通不過，所以，對類型參數進行約束是必須的。
C#中有4種約束可以使用，它們的語法類似：約束要放在泛型方法或類型聲明的末尾，并且要使用where關鍵字。
（1）引用類型約束
表現形式為T:class，它確保傳遞的類型實參必須是引用類型。
注意，約束的類型參數和類型本身沒有關系，即在定義一個泛型結構體時，泛型類型一樣可以被約束為引用類型。其中有幾個特殊的引用類型是不能用的：System.Array、System.Delegate、System.MulticastDelegate、System.ValueType、System.Enum、System.Void。
下面代碼定義的泛型類：
public class samplehere<T> where T:Stream
{
public void Test(T stream)
{
strem.Close();
}
}
從以上的代碼中，類型參數T設置了引用類型約束。where T :Stream的意思是告訴編譯器：傳入的類型實參必須是System.IO.System，或者是從Stream派生的一個類型。
如果一個類型參數沒有指定約束，則默認T為System.Object類型。但若你在代碼中顯式地指定了System.Object約束，則編譯器會報錯。
（2）值類型約束
值類型約束的表示形式為T:Struct,它確保傳遞的類型實參是值類型，包括枚舉。但這里的值類型不包括可空類型。
public class samplevaluetype<T>:struct
{
public static T Test()
{
return new T();
}
}
在上面的代碼中，new T()是可以通過編譯的，因為T是一個值類型，而所有值類型都有一個公共的無參構造函數。但如果不對T進行約束，或約束為引用類型，上面的代碼就會報錯。
（3）構造函數類型約束
構造函數類型約束的表示形似為T:new（），如果類型參數有多個約束，則此約束必須最后指定。構造函數類型約束確保指定的類型參數有一個公共無參構造函數的非抽象類型。
這里需要注意一點：如果同時指定構造器約束和struct約束，C#編譯器會認為這是一個錯誤。因為這樣的指定是多余的，所有值類型都隱式地提供了一個無參公共構造函數。
（4）轉換類型約束
轉換類型約束的表示形式為T:基類名、T:接口名或T:U。T:基類名確保指定的類型實參必須是基類或派生自基類的子類；T:接口名確保指定的類型實參必須是接口或實現了該接口的類；而T:U則確保T提供的類型實參必須是U提供的類型實參或派生于U提供的類型實參，即前面一個類型實參必須是后面的類型實參或后面類型的實參子類。
（5）組合約束
組合約束是將多個不同種類的約束合并在一起的情況。這里就需要注意，沒有任何一種類型既是引用類型，又是值類型，所以引用約束和值約束不能同時使用。如果存在多個轉換類型約束，其其中一個是類，則必須放在接口的前面。不同類型參數可以有不同的約束，但每種類型參數必須分別使用一個單獨的where關鍵字。
class Sample<T> where T:class,Disposable,new();
class Sample<T,U> where T:class where U:struct?
?
總結：至此，泛型已經講完了，應該有一個全面的認識了。不過還是要多敲代碼，不斷實踐，才能提高。
轉載于:https://www.cnblogs.com/Helius/p/5425164.html
總結
- 上一篇： 红米Redmi AX5400路由器，一句
- 下一篇： 每日站立会议（六）