3.C#中泛型类的进一步探讨

阅读目录

　一：多重泛型
　　  class不仅可以有T，还可以有K，实例化的时候传多个数据类型的类型，C#集合类型中的Dictionary就是多重泛型

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace MultipleGeneric
 {
     class Program
     {
         static void Main(string[] args)
         {
             MyGenericArray<int, char> intArray = new MyGenericArray<int, char>();
             for (int i = ; i < ; i++)
             {
                 intArray.SetItem(i, i * );
             }
             for (int i = ; i < ; i++)
             {
                 Console.WriteLine(intArray.GetItem(i) + "");
             }
             MyGenericArray<char, string> charArray = new MyGenericArray<char, string>();

             MyGenericArray<string, string> stringArray = new MyGenericArray<string, string>();
             for (int i = ; i < ; i++)
             {
                 charArray.SetItem(i, (char)(i + ));
             }
             for (int i = ; i < ; i++)
             {
                 Console.WriteLine(charArray.GetItem(i) + "");
             }

             Console.ReadLine();
         }
     }

     class MyGenericArray<T,K>
     {
         private T[] array;

         public MyGenericArray(int size)
         {
             array = new T[size + ];
         }

         public T GetItem(int index)
         {
             return array[index];
         }

         public void SetItem(int index, T value)
         {
             array[index] = value;
         }
     }

　二：泛型的数据类型参数可以带限制的
　　  泛型的数据类型可以带限制的，规定T只能传值类型或者传引用类型，这里限制为第一个数据类型T为值类型

     //可以限制为class,interface,具体的class
     class MyGenericArray<T,K> where T:struct
     {
         private T[] array;

         public MyGenericArray(int size)
         {
             array = new T[size + ];
         }

         public T GetItem(int index)
         {
             return array[index];
         }

         public void SetItem(int index, T value)
         {
             array[index] = value;
         }
     }

　三：继承中泛型的处理

像SubMyGenericArray继承的时候强制规定只实现了对int的继承，它不在是一个泛型类了，像SubMyGenericArray2继承的时候，子类还是一个泛型类

     //可以限制为class,interface,具体的class
     class MyGenericArray2<T> where T : struct
     {
         private T[] array;

         public MyGenericArray2()
         {
         }

         public MyGenericArray2(int size)
         {
             array = new T[size + ];
         }

         public T GetItem(int index)
         {
             return array[index];
         }

         public void SetItem(int index, T value)
         {
             array[index] = value;
         }
     }

     //继承的时候强制规定只实现了对int的继承，子类不在是一个泛型类了
     class SubMyGenericArray : MyGenericArray2<int>
     { 

     }

     //继承的时候，子类还是一个泛型类
     class SubMyGenericArray2<T> : MyGenericArray2<T> where T:struct
     {

     }