詳解C#中的泛型以及編程中使用泛型的優(yōu)點

更新時間：2016年02月02日 15:10:17 投稿：goldensun

這篇文章主要介紹了詳解C#中的泛型以及編程中使用泛型的優(yōu)點,對泛型的支持時C#語言中的重要特性,需要的朋友可以參考下

2.0 版 C# 語言和公共語言運行時 (CLR) 中增加了泛型。泛型將類型參數(shù)的概念引入 .NET Framework，類型參數(shù)使得設計如下類和方法成為可能：這些類和方法將一個或多個類型的指定推遲到客戶端代碼聲明并實例化該類或方法的時候。例如，通過使用泛型類型參數(shù) T，您可以編寫其他客戶端代碼能夠使用的單個類，而不致引入運行時強制轉換或裝箱操作的成本或風險，如下所示：

// Declare the generic class.
public class GenericList<T>
{
  void Add(T input) { }
}
class TestGenericList
{
  private class ExampleClass { }
  static void Main()
  {
    // Declare a list of type int.
    GenericList<int> list1 = new GenericList<int>();

    // Declare a list of type string.
    GenericList<string> list2 = new GenericList<string>();

    // Declare a list of type ExampleClass.
    GenericList<ExampleClass> list3 = new GenericList<ExampleClass>();
  }
}

泛型概述
使用泛型類型可以最大限度地重用代碼、保護類型的安全以及提高性能。
泛型最常見的用途是創(chuàng)建集合類。
.NET Framework 類庫在 System.Collections.Generic 命名空間中包含幾個新的泛型集合類。應盡可能地使用這些類來代替普通的類，如 System.Collections 命名空間中的 ArrayList。
您可以創(chuàng)建自己的泛型接口、泛型類、泛型方法、泛型事件和泛型委托。
可以對泛型類進行約束以訪問特定數(shù)據(jù)類型的方法。
關于泛型數(shù)據(jù)類型中使用的類型的信息可在運行時通過使用反射獲取。

泛型類和泛型方法同時具備可重用性、類型安全和效率，這是非泛型類和非泛型方法無法具備的。泛型通常用與集合以及作用于集合的方法一起使用。.NET Framework 2.0 版類庫提供一個新的命名空間 System.Collections.Generic，其中包含幾個新的基于泛型的集合類。建議面向 .NET Framework 2.0 及更高版本的所有應用程序都使用新的泛型集合類，而不要使用舊的非泛型集合類如 ArrayList。

當然，也可以創(chuàng)建自定義泛型類型和方法，以提供自己的通用解決方案，設計類型安全的高效模式。下面的代碼示例演示一個用于演示用途的簡單泛型鏈接列表類。（大多數(shù)情況下，應使用 .NET Framework 類庫提供的 List<T> 類，而不是自行創(chuàng)建類。）在通常使用具體類型來指示列表中存儲的項的類型的場合，可使用類型參數(shù) T。其使用方法如下：
在 AddHead 方法中作為方法參數(shù)的類型。
在 Node 嵌套類中作為公共方法 GetNext 和 Data 屬性的返回類型。
在嵌套類中作為私有成員數(shù)據(jù)的類型。
注意，T 可用于 Node 嵌套類。如果使用具體類型實例化 GenericList<T>（例如，作為 GenericList<int>），則所有的 T 都將被替換為 int。

// type parameter T in angle brackets
public class GenericList<T> 
{
  // The nested class is also generic on T.
  private class Node
  {
    // T used in non-generic constructor.
    public Node(T t)
    {
      next = null;
      data = t;
    }

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

    // T as private member data type.
    private T data;

    // T as return type of property.
    public T Data 
    {
      get { return data; }
      set { data = value; }
    }
  }

  private Node head;

  // constructor
  public GenericList() 
  {
    head = null;
  }

  // T as method parameter type:
  public void AddHead(T t) 
  {
    Node n = new Node(t);
    n.Next = head;
    head = n;
  }

  public IEnumerator<T> GetEnumerator()
  {
    Node current = head;

    while (current != null)
    {
      yield return current.Data;
      current = current.Next;
    }
  }
}

下面的代碼示例演示客戶端代碼如何使用泛型 GenericList<T> 類來創(chuàng)建整數(shù)列表。只需更改類型參數(shù)，即可方便地修改下面的代碼示例，創(chuàng)建字符串或任何其他自定義類型的列表：

class TestGenericList
{
  static void Main()
  {
    // int is the type argument
    GenericList<int> list = new GenericList<int>();

    for (int x = 0; x < 10; x++)
    {
      list.AddHead(x);
    }

    foreach (int i in list)
    {
      System.Console.Write(i + " ");
    }
    System.Console.WriteLine("\nDone");
  }
}

泛型的優(yōu)點
在公共語言運行時和 C# 語言的早期版本中，通用化是通過在類型與通用基類型 Object 之間進行強制轉換來實現(xiàn)的，泛型提供了針對這種限制的解決方案。通過創(chuàng)建泛型類，您可以創(chuàng)建一個在編譯時類型安全的集合。
使用非泛型集合類的限制可以通過編寫一小段程序來演示，該程序使用 .NET Framework 類庫中的 ArrayList 集合類。 ArrayList 是一個使用起來非常方便的集合類，無需進行修改即可用來存儲任何引用或值類型。

// The .NET Framework 1.1 way to create a list:
System.Collections.ArrayList list1 = new System.Collections.ArrayList();
list1.Add(3);
list1.Add(105);

System.Collections.ArrayList list2 = new System.Collections.ArrayList();
list2.Add("It is raining in Redmond.");
list2.Add("It is snowing in the mountains.");

但這種方便是需要付出代價的。添加到 ArrayList 中的任何引用或值類型都將隱式地向上強制轉換為 Object。如果項是值類型，則必須在將其添加到列表中時進行裝箱操作，在檢索時進行取消裝箱操作。強制轉換以及裝箱和取消裝箱操作都會降低性能；在必須對大型集合進行循環(huán)訪問的情況下，裝箱和取消裝箱的影響非常明顯。
另一個限制是缺少編譯時類型檢查；因為 ArrayList 會將所有項都強制轉換為 Object，所以在編譯時無法防止客戶端代碼執(zhí)行類似如下的操作：

System.Collections.ArrayList list = new System.Collections.ArrayList();
// Add an integer to the list.
list.Add(3);
// Add a string to the list. This will compile, but may cause an error later.
list.Add("It is raining in Redmond.");

int t = 0;
// This causes an InvalidCastException to be returned.
foreach (int x in list)
{
  t += x;
}

盡管將字符串和 ints 組合在一個 ArrayList 中的做法在創(chuàng)建異類集合時是完全可接受的，并且有時需要有意為之，但這種做法很可能產(chǎn)生編程錯誤，并且直到運行時才能檢測到此錯誤。
在 C# 語言的 1.0 和 1.1 版本中，只能通過編寫自己的特定于類型的集合來避免 .NET Framework 基類庫集合類中的通用代碼的危險。當然，由于此類不可對多個數(shù)據(jù)類型重用，因此將喪失通用化的優(yōu)點，并且您必須對要存儲的每個類型重新編寫該類。
ArrayList 和其他相似類真正需要的是：客戶端代碼基于每個實例指定這些類要使用的具體數(shù)據(jù)類型的方式。這樣將不再需要向上強制轉換為 T:System.Object，同時，也使得編譯器可以進行類型檢查。換句話說，ArrayList 需要一個類型參數(shù)。這正是泛型所能提供的。在 N:System.Collections.Generic 命名空間的泛型 List<T> 集合中，向集合添加項的操作類似于以下形式：

// The .NET Framework 2.0 way to create a list
List<int> list1 = new List<int>();

// No boxing, no casting:
list1.Add(3);

// Compile-time error:
// list1.Add("It is raining in Redmond.");

對于客戶端代碼，與 ArrayList 相比，使用 List<T> 時添加的唯一語法是聲明和實例化中的類型參數(shù)。雖然這種方式稍微增加了編碼的復雜性，但好處是您可以創(chuàng)建一個比 ArrayList 更安全并且速度更快的列表，對于列表項是值類型的情況尤為如此。

您可能感興趣的文章: