泛型接口

在自定义类型上总有点纠结,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 }

 

posted @ 2010-05-27 12:51  淡阳  阅读(634)  评论(0编辑  收藏  举报