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     }

 

 

 

posted @ 2016-02-29 21:34  David.Meng  阅读(2401)  评论(0)  编辑  收藏  举报