泛型接口

在自定义类型上总有点纠结，CTS中类型层次结构可以分为两个基本树，引用类型与值类型，引用类型直接派生自System.Object，值类型派生自特殊的CTS类型System.ValueType，而它本身是由System.Object派生的。

 

 

使用内置类型的泛型接口：

1 interface Test2 < T >
2 {
3 void Print(T t);
4 }
5
6 class TestA:Test2 < String >
7 {
8 public void Print( string str)
9 {
10 Console.WriteLine(str);
11 }
12 }

泛型实现了代码的复用和对类型进行了约束，接口则形成一种设计规范，对继承类的功能进行的标识、说明，内置的泛型接口使用起来简单，易懂。

 

使用where关键字实现泛型接口：

1 interface Test < T, V >
2 where T : class
3 where V : struct
4 {
5 void Print(T t,V v);
6 }
7
8 class TestA : Test < string , int >
9 {
10 public void Print( string name, int age)
11 {
12 Console.WriteLine(name + " is " + age);
13 }
14 }
15
16 // 使用自定义类型
17   class TestC
18 {
19 string _Name;
20
21 public string Name { get ; set ; }
22 }
23
24 struct TestD
25 {
26 int _Age;
27
28 public int Age { get ; set ; }
29 }
30
31 class TestB : Test < TestC,TestD >
32 {
33 public void Print(TestC C,TestD D)
34 {
35 Console.WriteLine(C.Name + " is " + D.Age);
36 }
37 }

 

使用自定义类型与使用内置类型是同样的，在使用前定义这两种类型，将其类型传递给泛型接口，使派生自泛型接口的类具备自定义类型的属性和方法。

 

使用限制派生自定义类型的泛型接口：

1 // IPromotable 接口，晋升到新工作岗位
2   // IGoodStudent 接口，出色的学生升一级
3   // Employee 类表示某公司的一名职员。
4   // Programmer 类表示公司的一名计算机程序员，程序员可以在公司内获得晋升
5   // Manager 类表示一位公司经理，经理可以在公司内获得晋升。所有经理都需要继续深造，以实现 IGoodStudent
6   // Intern 类表示公司的一名实习生，实习生是临时雇员，因此不符合晋升的条件
7
8   // 首先定义一个员工类
9 class Employee
10 {
11 private string _Name;
12
13 public string Name
14 {
15 get { return _Name; }
16 set { _Name = value; }
17 }
18 private string _Job;
19
20 public string Job
21 {
22 get { return _Job; }
23 set { _Job = value; }
24 }
25 }
26
27 // 其次定义两个晋升接口,一个为经理学习晋升接口,一个为程序员晋升接口,其类型都为员工类
28 interface IPromotable < T > where T:Employee
29 {
30 void JobUp();
31 }
32
33 interface IGoodStudent < T > where T:Employee
34 {
35 void StuUp();
36 }
37
38 // 继承自此两个接口的为经理和程序员
39 class Programmer : IPromotable < Employee >
40 {
41 public string name = new Employee().Name;
42 public void JobUp()
43 {
44 Console.WriteLine(name + " !Congraturation! " );
45 }
46 }
47
48 class Manager : IGoodStudent < Employee >
49 {
50 bool _Grade;
51
52 public bool Grade { get ; set ; }
53
54 public string job = new Employee().Job;
55 public string name = new Employee().Name;
56
57 public Manager( bool Grade)
58 {
59 this .Grade = Grade;
60 }
61
62
63 public void StuUp()
64 {
65
66 if (Grade)
67 {
68 Console.WriteLine(name + " !Congraturation!You did it!You are " + job + " ! " );
69 }
70 else
71 {
72 Console.WriteLine( " You must try agian.I am so sorry! " );
73 }
74 }
75 }
76
77 // 最后实现实习生类,此处是一个以Enployee为类型的一个新类
78 class Intern < T > where T : Employee
79 {
80 public void Print(T t)
81 {
82 Console.WriteLine(e.Name + " is just a Intern.No right to get the new job. " );
83 }
84 }
85 // 最后实现实习生类,此处是派生自Employee的一个子类
86 class Intern : Employee
87 {
88 public void Print(Employee e)
89 {
90 Console.WriteLine(e.Name + " is just a Intern.No right to get the new job. " );
91 }
92 }
93

个人觉得如果按公司为一个完整体来描述的话，Intern类的实现在于继承Employee类。T仅仅提供了一种类型约束。但前面的接口仅仅是限制类型为Employee，估计这里两种写法都可以。

给经理类和程序员类赋值时可以声明一个Empolyee对象作为参数传递给方法，这样写更符合泛型接口的使用：

1 class Programmer : IPromotable < Employee >
2 {
3 public void JobUp(Employee e)
4 {
5 Console.WriteLine(e.Name + " !Congraturation! " );
6 }
7 }
8
9 class Manager : IGoodStudent < Employee >
10 {
11 bool _Grade;
12
13 public bool Grade { get ; set ; }
14
15 public Manager( bool Grade)
16 {
17 this .Grade = Grade;
18 }
19
20
21 public void StuUp(Employee e)
22 {
23
24 if (Grade)
25 {
26 Console.WriteLine(e.Name + " !Congraturation!You did it!You are " + e.Job + " ! " );
27 }
28 else
29 {
30 Console.WriteLine( " You must try agian.I am so sorry! " );
31 }
32 }
33 }

 

转载于:https://www.cnblogs.com/IYang/archive/2010/05/27/1745262.html