转自:http://www.cnblogs.com/yangmingming/archive/2010/02/24/1672569.html
临近年终，和一朋友去应聘，偶见一C#选择题，问道：接口中不能包含什么？答案有：方法，属性，事件，字段。（我比较确定，应该选择字段，然而对于其确切原因却不能详述。这两天看到Steven John Metsker 的《C# 设计模式》中讲到“接口型模式设计”时，详细讲述了接口，以及接口中内容 。在此借助其讲述，将其做一概要。
接口和抽象类：
为了更好的理解接口，最常见的问题莫过于接口和抽象类的区别。如前所述，博文《IL应用之——用IL分析接口的本质》 中已详细概述，用IL反编译工具，可以得出接口的本质，即编译为中间语言时，是采用抽象类的实现机制实现的（实现多态！）。然而接口和抽象类却存在实实在在的差异，具体体现在：
1.一个类可以实现任意多个接口，但是最多只能对一个抽象类进行子类化；
2.一个抽象类可以包括非抽象方法，而一个接口的所有方法在效果上都是抽象的；
3.一个抽象类可以声明并使用变量，而一个接口不能；
4.一个抽象类中的方法的访问修饰符可以是：public，internal，protected，protected internal，或者private，而接口中默认情况下都是public，而且在声明接口成员时，不允许使用访问修饰符；
5.一个抽象类可以定义构造函数，而一个接口不能；
上述5点区别主要是使用上，之所以将其区分开，是因为其使用场景是不同的 ，即功用性所在，主要可概括为：抽象类用在具有族层关系的继承关系上；而接口用在具有功能性意义上。
接口中属性的实现：
通常情况下接口中都是对应方法，然而其确实可以对属性 进行同样操作（以前只是知道，现在用代码实现之。）先看如下代码：
//CopyRight: http://www.cnblogs.com/yangmingming
//Notes: 为简便，将接口、类的建立，和验证代码放于一起
namespace ContentOfInterfaceDemo
{
public interface IFlyable
{
int Distance { get; }
string TypeOfFly { get; set; }
}
public class Bird : IFlyable
{
private int distance;
private string typeOfFly;
public int Distance
{
get { return distance; }
}
public string TypeOfFly
{
get { return typeOfFly; }
set { typeOfFly = value; }
}
}
class Program
{
static void Main(string[] args)
{
Bird bird = new Bird();
// bird.Distance = 10;
bird.TypeOfFly = "Using his Wings.";
Console.WriteLine("distance:{0},TypeOfFly:{1}", bird.Distance, bird.TypeOfFly);
}
}
}
经调试，结果如下：
可见我们实现了接口属性的继承！
接口中属性实现分析：
之所以属性可以像方法一样实现继承效果，从本质上并不难理解。在博文中《初识Ildasm.exe——IL反编译的实用工具》中，用IL代码讲述了属性的实现机制，即转变为对应的get和set函数，这样 在此文中所谓的属性实现，都可以转化为方法的实现，即问题迎刃而解，呵呵~（由此可见IL代码的分析重要性！）
附：问题
一个接口中可以包含方法、C#属性、以及索引器。一个接口中也可以包含事件，但是不能包含委托，为什么？下节继续。。。
委托概述：
在 C 语言 的众多种类型指针中，有一种叫做“函数指针”，即是指函数的入口地址。在 C# 中委托的概念与其相类似。而与C 语言中函数指针不同的是，.NET 中的委托是类型安全的。
委托的使用：
同使用一个类相类似，首先定义要使用的委托，这里规定了委托所代表的哪种类型的方法； 其次创建该委托的一个或多个实例。这里举一示范代码：
//CopyRight: http://www.cnblogs.com/yangmingming
//Notes: 为简便，将委托的定义，和验证代码放于一起
namespace DelegateDemo
{
class Program
{
//委托的定义，制定对应方法的类型
public delegate int DelegateShowInt(int i);
public static int ShowData(int i)
{
return i + 1;
}
static void Main(string[] args)
{
DelegateShowInt showInt = new DelegateShowInt(ShowData);
Console.WriteLine("The Result is {0}", showInt(1));
}
}
}
最后调试结果为：
上例可见一般情况下，委托的应用，即在对应一个方法使用委托的情况下。
注意：
对于式：DelegateShowInt showInt = new DelegateShowInt(ShowData) 可以认为是所有委托都有的“构造函数”形式——其参数是函数引用。
多播委托：
前面例子中是最为简单、常用的一种形式（一个委托实例，调用一个方法）。因为我们可以实例化一个或多个某种委托的实例，另一方面，我们也可以让一个委托调用多个方法，这里称作多播委托。
//CopyRight: http://www.cnblogs.com/yangmingming
//Notes: 为简便，将委托的定义，和验证代码放于一起
namespace DelegateDemo
{
class Program
{
//定义委托,注意返回类型为 ：void
public delegate void DelegateShowInt(int i);
public static void ShowData(int i)
{
Console.WriteLine("ShowData is {0}", i);
}
public static void ShowData2(int i)
{
Console.WriteLine ("ShowData2 is {0}",i+1);
}
static void Main(string[] args)
{
//多播委托的使用方法：+=
DelegateShowInt showInt = new DelegateShowInt(ShowData);
showInt +=new DelegateShowInt( ShowData2);
showInt(1);
showInt(2);
}
}
}
而对应的调试结果为：
通过实例，可见我们对委托对象，实现了多个方法的绑定。
注意： 之所以要求多播委托的返回类型为void，是因为如果有返回值，将没有意义，起到作用的只有最后一个被调用的函数而已！
事件概述：
有了前述对委托的讲述，为这里讲解事件做好了铺垫。事件，其在Windows Form中得到极大应用，这里举一最常见的点击按钮，触发事件的例子。
2 {
3 this.buttonOne = new System.Windows.Forms.Button();
4 this.SuspendLayout();
5 //
6 // buttonOne
7 //
8 this.buttonOne.Location = new System.Drawing.Point(241, 37);
9 this.buttonOne.Name = "buttonOne";
10 this.buttonOne.Size = new System.Drawing.Size(75, 23);
11 this.buttonOne.TabIndex = 0;
12 this.buttonOne.Text = "button";
13 this.buttonOne.UseVisualStyleBackColor = true;
14 this.buttonOne.Click += new System.EventHandler(this.button_Click);
15 //
16 // Form1
17 //
18 this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
19 this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
20 this.ClientSize = new System.Drawing.Size(292, 266);
21 this.Controls.Add(this.buttonOne);
22 this.Name = "Form1";
23 this.Text = "Form1";
24 this.ResumeLayout(false);
25
26 }
可见在14行，对对象buttonOne的事件Click赋予了委托，该委托指定了形式：
{
}
对应类型的参数含有object和EventArgs，并且返回为void形式。这样事件就与委托相联系上。
同样可以实现不同对象的事件，对应同一委托情形：
this.buttonTwo.Click += new System.EventHandler(this.button_Click);
综上可见：
1.委托，作为一种特殊的类型，雷同于定义一个类（实际上，后台即是将其作为类处理） ；
2.事件，规范了其类型（委托类型）；
综上之，之所以接口不能包含委托，而接口为什么可以包含事件呢？
因为委托是一种与类同等地位的特殊类型（类的实例是存储数据的托管内存空间，而委托则只有方法地址而已），故接口不能包含委托；事件从地位上不与类、接口同一层次，事件的独特机制使得事件可以是一个接口的标准组成部分，只要继承的类包含一个public事件成员；（看样要想说明白，还要将事件讲述更清楚些，呵呵~）
附：附加版
如上文所述，事件一般都是应用在诸如Windows form这样的事件驱动环境中。具体例子可见上述按钮触发事件自动生成的代码。然而对事件而言，我们自己也可以定义事件的，见下例：
2
3 //CopyRight: http://www.cnblogs.com/yangmingming
4
5 //Notes: 为简便，将自定义事件的定义，和验证代码放于一起
6
7
8 namespace SelfDefinitionEvent
9 {
10 //先定义一委托类型
11 public delegate void DelegateDog( );
12
13
14 public class Dog
15 {
16 //定义事件类型，其类型对应于自定义委托类型
17 public event DelegateDog EventDog;
18 private string name;
19 public string Name
20 {
21 get { return name; }
22 set { name = value; }
23 }
24 public void Invoked()
25 {
26 //使用事件方法：像使用其对应方法一样使用
27 EventDog();
28 }
29 }
30 class Program
31 {
32 public static void Response()
33 {
34 Console.WriteLine("It will attack human.");
35 }
36 static void Main(string[] args)
37 {
38 Dog dog = new Dog();
39 dog.Name = "Jack";
40 //对事件的操作，使之与对应委托相关
41 dog.EventDog += new DelegateDog(Response);
42 dog.Invoked();
43
44 }
45 }
46 }
47
最后结果为：
从上例，可以看到自定义事件的从定义、赋值、使用等个部分的方法，也可以加深对事件的了解。
索引器的概述：
索引器（indexer）是类中相当特殊的一类成员，其功能类似于数组，对象可以按照索引编号对对象中的集合进行存（set）和取（get）操作。这是雷同于数组的方面。然而在类中声明、定义方式，却更相似于属性——同样采用get 和 set访问器（accessor）。 在此只是简要说明，下面用一代码具体实现之，同时也有了索引器的初步理解：
2
3 //CopyRight: http://www.cnblogs.com/yangmingming
4
5 //Notes: 为简便，将类Student和类Team，以及验证代码放于一起。同时没有对索引中的索引编号越界做判断
6 namespace IndexerAtClassDemo
7 {
8 //对类Student 的定义，以便于类Team 中应用
9 public class Student
10 {
11 private string name;
12 public string Name
13 {
14 get { return name; }
15 set { name = value; }
16 }
17 }
18
19 //类Team的定义
20 public class Team
21 {
22 //先声明一Student 数组
23 private Student[] student = new Student[10];
24
25 //通过索引编号来引用
26 public Student this[int i]
27 {
28 get { return student[i]; }
29 set { student[i] = value; }
30 }
31
32 //通过关键字来引用
33 public Student this[string n]
34 {
35 get
36 {
37 foreach (Student s in student)
38 {
39 if (s.Name == n)
40 return s;
41 }
42 return null;
43 }
44 }
45
46 }
47 public class Program
48 {
49 static void Main(string[] args)
50 {
51 //声明两个Student对象
52 Student s1 = new Student();
53 s1.Name = "Yangmingming";
54 Student s2 = new Student();
55 s2.Name = "Youngman";
56
57 //声明Team对象
58 Team team = new Team();
59 team[0] = s1;
60 team[1] = s2;
61
62 //用索引号和关键字作为条件的，对象索引引用
63 Console.WriteLine("The name of s1 and s2 is {0},{1}",team[0].Name ,team [1].Name);
64 Console.WriteLine("The name of s1 and s2 is {0},{1}",team ["Yangmingming"].Name,team ["Youngman"].Name );
65
66 }
67 }
68 }
69
两条输出语句，实现了相同的输出结果，为：
从上基本了解到了索引的应用方法，而此时越发的感觉索引，同数组，和属性，有点难以区分。他们的相同点区别大至如下：
1. 索引器，和属性一样，内部实现了get 和set 访问器；
2.在功能上，索引器对于对象而言，实现了数组的功效，同时索引器比数组范围更大：在实现了索引编号访问同时，还实现了关键字索引引用的效果；
3.所有索引器都使用 this 关键字来定义 ；
4.索引器不可以像属性一样，定义为 Static 类型；等等；
索引器在接口中的实现：
前已概述了索引器的基本概念，以及使用方法，现在讨论索引器在接口中的实现方法。由前对接口中属性的实现方法而自然而然联想，我们有理由相信索引器在接口中应该实现为与属性相似的方法，事实的确如此，见如下代码：
2
3 //CopyRight: http://www.cnblogs.com/yangmingming
4
5 //Notes: 为简便，将接口IShowInt和类CShowInt，以及验证代码放于一起。
6 namespace IndexAtInterfaceDemo
7 {
8 //在接口上的索引器定义（indexer）
9 public interface IShowInt
10 {
11
12 int this[int index]
13 {
14 get;
15 set;
16 }
17 }
18
19 //在实现接口的类上，定义索引器（indexer）
20 public class CShowInt
21 {
22 private int[] arr = new int[100];
23
24 public int this[int index]
25 {
26 get
27 {
28 //确定集合 边界 问题
29 if (index >= 0 && index <= 99)
30 {
31 return arr[index];
32 }
33 return 0;
34 }
35 set
36 {
37 if (index >= 0 && index <= 99)
38 arr[index] = value;
39 }
40 }
41 }
42 public class Program
43 {
44 static void Main(string[] args)
45 {
46 CShowInt cShowInt = new CShowInt();
47
48 //对对象使用其中索引器
49 cShowInt[0] = 1;
50 cShowInt[1] = 2;
51
52 Console.WriteLine("The int of the Class CShowInt by index is {0},{1}",cShowInt [0],cShowInt [1]);
53
54 }
55 }
56 }
其实现结果，如下图示：
即实现了接口中索引器的实现。
综述，经过这三篇关于接口中包含内容的讨论，进一步加深了对接口的理解，同时也 进一步学习委托与事件、索引器等。