C#语言进阶——6.C# 的泛型

Posted 2020-08-21

1.C# 中泛型在 Class 上的实现

   泛型是什么意思呢，就是说我们在编程的时候，需要一个数据类型，刚开的时候不知道数据类型是什么样子。或者多个类型相同的操作，不想重复的写代码，就需要一个泛型来表示一个同样的操作来表示不同的类型。类型安全，性能比较好。

 1  class Program
 2     {
 3 
 4         static void Main(string[] args)
 5         {
 6             //规定一个泛型是整型，这么一个数组
 7             MyGenericArray<int> intArray = new MyGenericArray<int>(5);
 8             //给每一位赋值
 9             for (int c = 0; c < 5; c++)
10             {
11                 intArray.SetItem(c, c * 5);
12             }
13             //输出出来
14             for (int c = 0; c < 5; c++)
15             {
16                 Console.WriteLine(intArray.GetITem(c) + "");
17             }
18             Console.WriteLine();
19 
20             MyGenericArray<char> charArray = new MyGenericArray<char>(5);
21 
22             //给每一位赋值
23             for (int c = 0; c < 5; c++)
24             {
25                 charArray.SetItem(c, (char)(c+97));
26             }
27             //输出出来
28             for (int c = 0; c < 5; c++)
29             {
30                 Console.WriteLine(charArray.GetITem(c) + "");
31             }
32 
33             Console.ReadLine();
34         }
35     }
36     public class MyGenericArray<T>//用<T>来表示我用到了一个泛型
37     {
38         private T[] array;//一个成员变量，数组
39         /// <summary>
40         /// 构造函数
41         /// </summary>
42         /// <param name="size">传进来一个整型,第一个传进来的数组进行一个初始化</param>
43         public MyGenericArray(int size)
44         {
45             array = new T[size + 1];
46         }
47 
48         //创建两个方法，来获取数组的内容
49         public T GetITem(int index)
50         {
51             return array[index];
52         }
53         public void SetItem(int index, T value)
54         {
55             array[index] = value;
56         }
57     }

 

2.C# 泛型类的进一步探讨：泛型类的多个泛型的实现，泛型参数的限制，以及泛型类的继承。

 1 public class MyGenericArray<T,k>//用<T>和 K 来表示我用到了一个泛型,可以传送多个泛型的类型 {  } 

 1 public class MyGenericArray<T,k> where T: struct//泛型参数的限制:这样的话就只能是c#值类型 还可以 Class interface instance Calss{} 

1     public class SubCalss: MyGenericArray<int> { } //只能继承泛型的int类
2     public class SubCalss2<T> : MyGenericArray<T> where T : struct { } //继承同样是继续是泛型的

3.C# 泛型在 方法Method 上的实现

 1 class Program
 2     {
 3 
 4         static void Main(string[] args)
 5         {
 6 
 7             MyGenericArray<int> intArray = new MyGenericArray<int>(5);
 8             //  方法数据类型的调用,在已有的泛型class上 执行的泛型方法
 9             intArray.GenericMethod<string>("Heelo Generic!");
10             intArray.GenericMethod<int>(100);
11 
12             //在没有泛型的class上 执行的泛型方法
13             int a, b;
14             char c, d;
15             a = 10;
16             b = 20;
17             c = ‘I‘;
18             d = ‘V‘;
19             Console.WriteLine("a：{0},b:{1}", a, b);
20             Console.WriteLine("c：{0},d:{1}", c, d);
21             Swap<int>(ref a, ref b);
22             Swap<char>(ref c, ref d);
23             Console.WriteLine("a：{0},b:{1}", a, b);
24             Console.WriteLine("c：{0},d:{1}", c, d);
25             Console.ReadLine();
26         }
27 
28         //泛型在方法上的实现同样可以是一个静态方法，ref 关键字 引用
29         private static void Swap<T>(ref T lhs, ref T rhs)
30         {
31             //交换两个变量的数值
32             T temp;
33             temp = lhs;
34             lhs = rhs;
35             rhs = temp;
36 
37         }
38     }
39 
40     public class MyGenericArray<T> where T : struct//泛型参数的限制:这样的话就只能是c#值类型 还可以 Class  interface instance Calss
41     {
42         private T[] array;//一个成员变量，数组
43         /// <summary>
44         /// 构造函数
45         /// </summary>
46         /// <param name="size">传进来一个整型,第一个传进来的数组进行一个初始化</param>
47         public MyGenericArray(int size)
48         {
49             array = new T[size + 1];
50         }
51 
52         //创建两个方法，来获取数组的内容
53         public T GetITem(int index)
54         {
55             return array[index];
56         }
57         public void SetItem(int index, T value)
58         {
59             array[index] = value;
60         }
61 
62         //如果我们要用到一个泛型方法跟这边的T不一定同一个数据类型的做法 
63         public void GenericMethod<X>(X x)
64         {
65             Console.WriteLine(x.ToString());
66         }
67     }

 

4.C# 泛型在委托 Delegate 上的实现

 1  class Program
 2     {
 3         //实现个委托，里面是泛型的,所有用到数据类型的都可以用到一个T，返回的也是T
 4         delegate T NumberChanger<T>(T n);
 5         //
 6         static int num = 10;
 7 
 8         //实现了一个加数值的一个功能
 9         public static int AddNum(int p)//还是一个静态的 因为静态的可以直接被Main 函数调用
10         {
11             num += p;
12             return num;
13         }
14 
15         //实现了一个乘数值的一个功能
16         public static int NultNum(int p)//还是一个静态的 因为静态的可以直接被Main 函数调用
17         {
18             num *= p;
19             return num;
20 
21         }
22         static void Main(string[] args)
23         {
24             NumberChanger<int> nc1 = new NumberChanger<int>(AddNum);
25             NumberChanger<int> nc2 = new NumberChanger<int>(NultNum);
26             nc1(25);
27             Console.WriteLine(num);
28             nc2(5);
29             Console.WriteLine(num);
30             Console.ReadLine();
31         }
32 
33 
34     }