Posted by & filed under Uncategorized.

About yangwei

wei yang has written 16 post in this blog.

        泛型是 2.0 版 C# 语言和公共语言运行库 (CLR) 中的一个新功能。泛型将类型参数的概念引入 .NET Framework,类型参数使得设计如下类和方法成为可能:这些类和方法将一个或多个类型的指定推迟到客户端代码声明并实例化该类或方法的时候。例如,通过使用泛型类型参数 T,您可以编写其他客户端代码能够使用的单个类,而不致引入运行时强制转换或装箱操作的成本或风险,避免进行强制类型转换的需求提高类型安全性。

泛型概述及优点

        泛型类和泛型方法同时具备可重用性、类型安全和效率高等特点。它通常用在集合和在集合上运行的方法中。.NET 2.0版类库提供了一个新的名为System.Collections.Generic的命名空间,其中包含几个新的基于泛型的集合类。
        也可以创建自定义泛型类型和方法。
        泛型类和方法接收”类型参数“,指定了要操作的对象的类型:
  1. public class Test<T> {}  

在实例化时才指定类型。

  1. Test<int> tree = new Test<int>();   

使用泛型类型有以下优点:

  1. 使用泛型类型可以最大限度地重用代码、保护类型的安全以及提高性能。
  2. 泛型最常见的用途是创建集合类。
  3. .NET Framework 类库在 System.Collections.Generic 命名空间中包含几个新的泛型集合类。应尽可能地使用这些类来代替普通的类,如 System.Collections 命名空间中的 ArrayList。
  4. 您可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
  5. 可以对泛型类进行约束以访问特定数据类型的方法。
  6. 关于泛型数据类型中使用的类型的信息可在运行时通过反射获取。

泛型中的类型参数T

        类型参数T用来定义泛型类时的占位符,并不是一种类型,仅代表某种可能的类型。在定义时,T出现的位置可以在使用是用任何类型来代替。

决定在何时何地使用泛型

        您需要考虑以下几件事件:
  • 您所使用的类型是否包含或操作未指定的数据类型(如集合类型)?如果是这样,创建泛型类型将能提供更多的好处。如果您的类型只操作单一的指定类型,那么就没有必要去创建一个泛型类。
  • 如果您的类型将操作值类型,那么就会产生装箱和拆箱操作,就应该考虑使用泛型来防止装箱和拆箱操作。
  • 泛型的强类型检查有助于快速查找错误(也就是编译期而非运行期),从而缩短bug修复周期。
  • 在编写多个类操作多个数据类型时是否遭遇到“代码膨胀”问题(如一个ArrayList只存储StreamReaders而另一个存储StreamWriters)?其实编写一次代码并让它工作于多个数据类型非常简单。
  • 泛型使得代码更为清晰。通过消除代码膨胀并进行强制检查,您的代码将变得更易于阅读和理解。

针对类的泛型

        针对不同类型的数组,写一个针对数组的”冒泡排序“。

思路

  • 针对类的泛型,泛型打在类旁。
  • 由于在”冒泡排序“中需要对元素进行比较,所以泛型要约束成实现IComparable接口。
  1. namespace ConsoleApplication1  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             SortHelper<int> isorter = new SortHelper<int>();  
  8.             int[] iarray = { 8, 7, 1, 2, 12 };  
  9.             isorter.BubbleSort(iarray);  
  10.             foreach (int item in iarray)  
  11.             {  
  12.                 Console.Write(item + “,”);  
  13.             }  
  14.             Console.ReadKey();  
  15.         }  
  16.     }  
  17.   
  18.     public class SortHelper<T> where T : IComparable  
  19.     {  
  20.         public void BubbleSort(T[] array)  
  21.         {  
  22.             int length = array.Length;  
  23.             for (int i = 0; i <= length – 2; i++)  
  24.             {  
  25.                 for (int j = length – 1; j >= 1; j–)  
  26.                 {  
  27.                     if (array[j].CompareTo(array[j – 1]) < 0)  
  28.                     {  
  29.                         T temp = array[j];  
  30.                         array[j] = array[j – 1];  
  31.                         array[j – 1] = temp;  
  32.                     }  
  33.                 }  
  34.             }  
  35.         }  
  36.     }  
  37. }  

输出:

1,2,7,8,12,

 

关于泛型约束

  • where T : IComparable 把T约束为实现IComparable接口
  • where T : class
  • where T : struct
  • where T : IComparable, new() 约束泛型必须有构造函数

关于冒泡算法

  • 之所以for (int i = 0; i <= length -2; i++),这是边界思维,比如有一个长度为5的数组,如果0号位元素最终调换到4号位,每次调一个位,需要经过4次才能到4号位,即for(int i = 0; i <= 5-2, i++),i依次为0, 1, 2, 4,期间经历了4次。
  • 至于for (int j = length – 1; j >= 1; j–)循环,即遍历从最后一个元素开始到索引为1的元素,每次与前一个位置上的元素比较。

关于比较

        int 类型之所以能比较,是因为int类型实现了IComparable接口。byte类型也一样。

自定义一个类,使之也能实现冒泡算法

        冒泡算法涉及到元素比较,所以自定义类必须实现IComparable接口。
  1. namespace ConsoleApplication1  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             Book[] bookArray = new Book[2];  
  8.             Book book1 = new Book(100, “书一”);  
  9.             Book book2 = new Book(80, “书二”);  
  10.             bookArray[0] = book1;  
  11.             bookArray[1] = book2;  
  12.   
  13.             Console.WriteLine(“冒泡之前:”);  
  14.             foreach (Book b in bookArray)  
  15.             {  
  16.                 Console.WriteLine(“书名:{0},价格:{1}”, b.Title, b.Price);  
  17.             }  
  18.   
  19.             SortHelper<Book> sorter = new SortHelper<Book>();  
  20.             sorter.BubbleSort(bookArray);  
  21.             Console.WriteLine(“冒泡之后:”);  
  22.             foreach (Book b in bookArray)  
  23.             {  
  24.                 Console.WriteLine(“书名:{0},价格:{1}”, b.Title, b.Price);  
  25.             }  
  26.             Console.ReadKey();  
  27.         }  
  28.     }  
  29.   
  30.     public class SortHelper<T> where T : IComparable  
  31.     {  
  32.         public void BubbleSort(T[] array)  
  33.         {  
  34.             int length = array.Length;  
  35.             for (int i = 0; i <= length – 2; i++)  
  36.             {  
  37.                 for (int j = length – 1; j >= 1; j–)  
  38.                 {  
  39.                     if (array[j].CompareTo(array[j – 1]) < 0)  
  40.                     {  
  41.                         T temp = array[j];  
  42.                         array[j] = array[j – 1];  
  43.                         array[j – 1] = temp;  
  44.                     }  
  45.                 }  
  46.             }  
  47.         }  
  48.     }  
  49.   
  50.     //自定义实现IComparable接口  
  51.     public class Book : IComparable  
  52.     {  
  53.         private int price;  
  54.         private string title;  
  55.   
  56.         public Book(){ }  
  57.         public Book(int price, string title)  
  58.         {  
  59.             this.price = price;  
  60.             this.title = title;  
  61.         }  
  62.   
  63.         public int Price  
  64.         {  
  65.             get   
  66.             {  
  67.                 return this.price;  
  68.             }  
  69.         }  
  70.   
  71.         public string Title  
  72.         {  
  73.             get  
  74.             {  
  75.                 return this.title;  
  76.             }  
  77.         }  
  78.   
  79.         public int CompareTo(object obj)  
  80.         {  
  81.             Book book = (Book)obj;  
  82.             return this.Price.CompareTo(book.Price);  
  83.         }  
  84.     }  
  85. }  

输出:

冒泡之前:

书名:书一,价格:100

书名:书二,价格:80

冒泡之后:

书名:书二,价格:80

书名:书一,价格:100

针对方法的泛型

        继续上面的例子,自定义一个类,并定义泛型方法。
  1. namespace ConsoleApplication1  
  2. {  
  3.     // 方法泛型  
  4.     public class MethodSortHelper  
  5.     {  
  6.         public void BubbleSort<T>(T[] array) where T : IComparable  
  7.         {  
  8.             int length = array.Length;  
  9.             for (int i = 0; i <= length – 2; i++)  
  10.             {  
  11.                 for (int j = length – 1; j >= 1; j–)  
  12.                 {  
  13.                     if (array[j].CompareTo(array[j – 1]) < 0)  
  14.                     {  
  15.                         T temp = array[j];  
  16.                         array[j] = array[j – 1];  
  17.                         array[j – 1] = temp;  
  18.                     }  
  19.                 }  
  20.             }  
  21.         }  
  22.     }  
  23. }  

主程序如下:

  1. namespace ConsoleApplication1  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             Book[] bookArray = new Book[2];  
  8.             Book book1 = new Book(100, “书一”);  
  9.             Book book2 = new Book(80, “书二”);  
  10.             bookArray[0] = book1;  
  11.             bookArray[1] = book2;  
  12.   
  13.             Console.WriteLine(“冒泡之前:”);  
  14.             foreach (Book b in bookArray)  
  15.             {  
  16.                 Console.WriteLine(“书名:{0},价格:{1}”, b.Title, b.Price);  
  17.             }  
  18.   
  19.             MethodSortHelper sorter = new MethodSortHelper();  
  20.             sorter.BubbleSort<Book>(bookArray);  
  21.             Console.WriteLine(“冒泡之后:”);  
  22.             foreach (Book b in bookArray)  
  23.             {  
  24.                 Console.WriteLine(“书名:{0},价格:{1}”, b.Title, b.Price);  
  25.             }  
  26.             Console.ReadKey();  
  27.         }  
  28.     }  
  29.   
  30.     //自定义实现IComparable接口  
  31.     public class Book : IComparable  
  32.     {  
  33.         private int price;  
  34.         private string title;  
  35.   
  36.         public Book() { }  
  37.         public Book(int price, string title)  
  38.         {  
  39.             this.price = price;  
  40.             this.title = title;  
  41.         }  
  42.   
  43.         public int Price  
  44.         {  
  45.             get  
  46.             {  
  47.                 return this.price;  
  48.             }  
  49.         }  
  50.   
  51.         public string Title  
  52.         {  
  53.             get  
  54.             {  
  55.                 return this.title;  
  56.             }  
  57.         }  
  58.   
  59.         public int CompareTo(object obj)  
  60.         {  
  61.             Book book = (Book)obj;  
  62.             return this.Price.CompareTo(book.Price);  
  63.         }  
  64.     }  
  65. }  

输出:

冒泡之前:

书名:书一,价格:100

书名:书二,价格:80

冒泡之后:

书名:书二,价格:80

书名:书一,价格:100

使用泛型方法的时候,除了这样:
  1. MethodSortHelper sorter = new MethodSortHelper();     
  2. sorter.BubbleSort<Book>(bookArray);   

还可以这样写:

  1. MethodSortHelper sorter = new MethodSortHelper();     
  2. sorter.BubbleSort(bookArray);   

可见,泛型方法可以根据数据实例隐式推断泛型是否满足条件。

泛型的其他优点

避免隐式装箱和拆箱

        以下包含隐式装箱和拆箱:
  1. ArrayList list = new ArrayList();    
  2. for(int i = 0; i < 3; i++)    
  3. {    
  4.   list.Add(i); //Add接收的参数类型是引用类型object,这里包含了隐式装箱    
  5. }    
  6. for(int i = 0; i < 3; i++)    
  7. {    
  8.   int value = (int)list[i]; //引用类型强转成值类型,拆箱    
  9.   Console.WriteLine(value);    
  10. }   

使用泛型避免隐式装箱和拆箱:

  1. List<int> list = new List<int>();    
  2. for(int i = 0; i < 3; i++)    
  3. {    
  4.   list.Add(i);    
  5. }    
  6. for(int i = 0; i < 3; i++)    
  7. {    
  8.   int value = list[i];    
  9.   Console.WriteLine(value);    
  10. }   

能在编译期间及时发现错误

        不使用泛型,在编译期间不会报错的一个例子:
  1. List<int> list = new List<int>();    
  2. for(int i = 0; i < 3; i++)    
  3. {    
  4.   list.Add(i);    
  5. }    
  6. for(int i = 0; i < 3; i++)    
  7. {    
  8.   int value = list[i];    
  9.   Console.WriteLine(value);    
  10. }   

使用泛型,在编译期间及时发现错误:

  1. List<int> list = new List<int>();    
  2. int i = 100;    
  3. list.Add(i);    
  4. string value = (string)list[0];   

使用泛型的技巧

在当前文件中给泛型起别名

  1. using IntList = List<int>;    
  2. IntList list = new IntList();    
  3. list.Add(1);

在不同文件中使用泛型别名,定义一个类派生于泛型

  1. public class IntList : List<int>{}  

Leave a Reply

  • (will not be published)