3.C#中泛型類的進一步探討

閱讀目錄

　一：多重泛型
　　  class不只能夠有T，還能夠有K，實例化的時候傳多個數據類型的類型，C#集合類型中的Dictionary就是多重泛型

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace MultipleGeneric
 8 {
 9     class Program
10     {
11         static void Main(string[] args)
12         {
13             MyGenericArray<int, char> intArray = new MyGenericArray<int, char>(5);
14             for (int i = 0; i < 5; i++)
15             {
16                 intArray.SetItem(i, i * 5);
17             }
18             for (int i = 0; i < 5; i++)
19             {
20                 Console.WriteLine(intArray.GetItem(i) + "");
21             }
22             MyGenericArray<char, string> charArray = new MyGenericArray<char, string>(5);
23 
24             MyGenericArray<string, string> stringArray = new MyGenericArray<string, string>(5);
25             for (int i = 0; i < 5; i++)
26             {
27                 charArray.SetItem(i, (char)(i + 97));
28             }
29             for (int i = 0; i < 5; i++)
30             {
31                 Console.WriteLine(charArray.GetItem(i) + "");
32             }
33 
34             Console.ReadLine();
35         }
36     }
37 
38     
39     class MyGenericArray<T,K>
40     {
41         private T[] array;
42 
43         public MyGenericArray(int size)
44         {
45             array = new T[size + 1];
46         }
47 
48         public T GetItem(int index)
49         {
50             return array[index];
51         }
52 
53         public void SetItem(int index, T value)
54         {
55             array[index] = value;
56         }
57     }

　二：泛型的數據類型參數能夠帶限制的
　　  泛型的數據類型能夠帶限制的，規定T只能傳值類型或者傳引用類型，這裏限制爲第一個數據類型T爲值類型

 1     //能夠限制爲class,interface,具體的class
 2     class MyGenericArray<T,K> where T:struct
 3     {
 4         private T[] array;
 5 
 6         public MyGenericArray(int size)
 7         {
 8             array = new T[size + 1];
 9         }
10 
11         public T GetItem(int index)
12         {
13             return array[index];
14         }
15 
16         public void SetItem(int index, T value)
17         {
18             array[index] = value;
19         }
20     }

　三：繼承中泛型的處理

像SubMyGenericArray繼承的時候強制規定只實現了對int的繼承，它不在是一個泛型類了，像SubMyGenericArray2繼承的時候，子類仍是一個泛型類

 1     //能夠限制爲class,interface,具體的class
 2     class MyGenericArray2<T> where T : struct
 3     {
 4         private T[] array;
 5 
 6         public MyGenericArray2()
 7         {
 8         }
 9 
10         public MyGenericArray2(int size)
11         {
12             array = new T[size + 1];
13         }
14 
15         public T GetItem(int index)
16         {
17             return array[index];
18         }
19 
20         public void SetItem(int index, T value)
21         {
22             array[index] = value;
23         }
24     }
25 
26     //繼承的時候強制規定只實現了對int的繼承，子類不在是一個泛型類了
27     class SubMyGenericArray : MyGenericArray2<int>
28     { 
29         
30     }
31 
32     //繼承的時候，子類仍是一個泛型類
33     class SubMyGenericArray2<T> : MyGenericArray2<T> where T:struct
34     {
35 
36     }