阅读目录
一：多重泛型
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 }