C# 接口（四 访问接口）

第四节 访问接口

　　对接口成员的访问

　　对接口方法的调用和采用索引指示器访问的规则与类中的情况也是相同的。如果底层成员的命名与继承而来的高层成员一致，那么底层成员将覆盖同名的高层成员。但由于接口支持多继承，在多继承中，如果两个父接口含有同名的成员，这就产生了二义性（这也正是C#中取消了类的多继承机制的原因之一），这时需要进行显式的定义：

1. using System;
2. interface ISequence
3. {
4.     int Count { get; set; }
5. }
6. interface IRing
7. {
8.     void Count(int i);
9. }
10. interface IRingSequence : ISequence, IRing { }
11. class CTest
12. {
13.     void Test(IRingSequence rs)
14.     {
15.         //rs.Count(1) ; 错误, Count 有二义性
16.         //rs.Count = 1; 错误, Count 有二义性
17.         ((ISequence)rs).Count = 1; // 正确
18.         ((IRing)rs).Count(1); // 正确调用IRing.Count
19.     }
20. }

　　上面的例子中，前两条语句rs.Count(1)和rs.Count = 1会产生二义性，从而导致编译时错误，因此必须显式地给rs指派父接口类型，这种指派在运行时不会带来额外的开销。

　　再看下面的例子：

1. using System;
2. interface IInteger
3. {
4.     void Add(int i);
5. }
6. interface IDouble
7. {
8.     void Add(double d);
9. }
10. interface INumber : IInteger, IDouble { }
11. class CMyTest
12. {
13.     void Test(INumber Num)
14.     {
15.         // Num.Add(1) ; 错误
16.         Num.Add(1.0); // 正确
17.         ((IInteger)n).Add(1); // 正确
18.         ((IDouble)n).Add(1); // 正确
19.     }
20. }

　　调用Num.Add(1)会导致二义性，因为候选的重载方法的参数类型均适用。但是，调用Num.Add(1.0)是允许的，因为1.0是浮点数参数类型与方法IInteger.Add()的参数类型不一致，这时只有IDouble.Add才是适用的。不过只要加入了显式的指派，就决不会产生二义性。

　　接口的多重继承的问题也会带来成员访问上的问题。例如：

1. interface IBase
2. {
3.     void FWay(int i);
4. }
5. interface ILeft : IBase
6. {
7.     new void FWay(int i);
8. }
9. interface IRight : IBase
10. {
11.     void G();
12. }
13. interface IDerived : ILeft, IRight { }
14. class CTest
15. {
16.     void Test(IDerived d)
17.     {
18.         d.FWay(1); // 调用ILeft. FWay
19.         ((IBase)d).FWay(1); // 调用IBase. FWay
20.         ((ILeft)d).FWay(1); // 调用ILeft. FWay
21.         ((IRight)d).FWay(1); // 调用IBase. FWay
22.     }
23. }

　　上例中，方法IBase.FWay在派生的接口ILeft中被Ileft的成员方法FWay覆盖了。所以对d.FWay(1)的调用实际上调用了。虽然从IBase-> IRight-> IDerived这条继承路径上来看,ILeft.FWay方法是没有被覆盖的。我们只要记住这一点：一旦成员被覆盖以后，所有对其的访问都被覆盖以后的成员"拦截"了。

　　类对接口的实现

　　前面我们已经说过，接口定义不包括方法的实现部分。接口可以通过类或结构来实现。我们主要讲述通过类来实现接口。用类来实现接口时，接口的名称必须包含在类定义中的基类列表中。

　　下面的例子给出了由类来实现接口的例子。其中ISequence 为一个队列接口，提供了向队列尾部添加对象的成员方法Add( )，IRing 为一个循环表接口，提供了向环中插入对象的方法Insert(object obj)，方法返回插入的位置。类RingSquence 实现了接口ISequence 和接口IRing。

1. using System;
2. interface ISequence 
3. {
4. 　object Add( ) ;
5. }
6. interface IRing
7. {
8. 　int Insert(object obj) ;
9. }
10. class RingSequence: ISequence, IRing
11. {
12. 　public object Add( ) {…}
13. 　public int Insert(object obj) {…}
14. } 

　　如果类实现了某个接口，类也隐式地继承了该接口的所有父接口，不管这些父接口有没有在类定义的基类表中列出。看下面的例子：

1. using System;
2. interface IControl
3. {
4.     void Paint();
5. }
6. interface ITextBox : IControl
7. {
8.     void SetText(string text);
9. }
10. interface IListBox : IControl
11. {
12.     void SetItems(string[] items);
13. }
14. interface IComboBox : ITextBox, IListBox { }

　　这里, 接口IcomboBox继承了ItextBox和IlistBox。类TextBox不仅实现了接口ITextBox，还实现了接口ITextBox 的父接口IControl。

　　前面我们已经看到，一个类可以实现多个接口。再看下面的例子：

1. interface IDataBound
2. {
3.     void Bind(Binder b);
4. }
5. public class EditBox : Control, IControl, IDataBound
6. {
7.     public void Paint();
8.     public void Bind(Binder b) {...}
9. }

　　类EditBox从类Control中派生并且实现了Icontrol和IdataBound。在前面的例子中接口Icontrol中的Paint方法和IdataBound接口中的Bind方法都用类EditBox中的公共成员实现。C#提供一种实现这些方法的可选择的途径，这样可以使执行这些的类避免把这些成员设定为公共的。接口成员可以用有效的名称来实现。例如，类EditBox可以改作方法Icontrol.Paint和IdataBound.Bind来实现。

1. public class EditBox : IControl, IDataBound
2. {
3.     void IControl.Paint() {...}
4.     void IDataBound.Bind(Binder b) {...}
5. }

　　因为通过外部指派接口成员实现了每个成员，所以用这种方法实现的成员称为外部接口成员。外部接口成员可以只是通过接口来调用。例如，Paint方法中EditBox的实现可以只是通过创建Icontrol接口来调用。

1. class Test
2. {
3.     static void Main()
4.     {
5.         EditBox editbox = new EditBox();
6.         editbox.Paint(); //错误: EditBox 没有Paint 事件
7.         IControl control = editbox;
8.         control.Paint(); // 调用 EditBox的Paint事件
9.     }
10. }

　　上例中，类EditBox 从Control 类继承并同时实现了IControl and IDataBound 接口。EditBox 中的Paint 方法来自IControl 接口，Bind 方法来自IDataBound 接口，二者在EditBox 类中都作为公有成员实现。当然，在C# 中我们也可以选择不作为公有成员实现接口。

　　如果每个成员都明显地指出了被实现的接口，通过这种途径被实现的接口我们称之为显式接口成员（explicit interface member）。用这种方式我们改写上面的例子：

1. public class EditBox: IControl, IDataBound 
2. {
3.     void IControl.Paint( ) {…}
4.     void IDataBound.Bind(Binder b) {…}
5. } 

　　显式接口成员只能通过接口调用。例如：

1. class CTest
2. {
3.     static void Main()
4.     {
5.         EditBox editbox = new EditBox();
6.         editbox.Paint(); //错误:不同的方法
7.         IControl control = editbox;
8.         control.Paint(); //调用 EditBox的Paint方法
9.     }
10. }

　　上述代码中对editbox.Paint( )的调用是错误的，因为editbox 本身并没有提供这一方法。control.Paint( )是正确的调用方式。

　　注释：接口本身不提供所定义的成员的实现，它仅仅说明这些成员，这些成员必须依靠实现接口的类或其它接口的支持。

　　知道了怎样访问接口，我们还要知道怎样实现接口,要实现C#的接口，请看下一节--实现接口