C#的接口基础教程之五 实现接口

1、显式实现接口成员

为了实现接口,类可以定义显式接口成员执行体(Explicit interface member implementations)。显式接口成员执行体可以是一个方法、一个属性、一个事件或者是一个索引指示器的定义,定义与该成员对应的全权名应保持一致。
 
using System ;
interface ICloneable {
 object Clone( ) ;
}
interface IComparable {
 int CompareTo(object other) ;
}
class ListEntry: ICloneable, IComparable {
 object ICloneable.Clone( ) {…}
 int IComparable.CompareTo(object other) {…}
}

上面的代码中ICloneable.Clone 和IComparable.CompareTo 就是显式接口成员执行体。

说明:

1、不能在方法调用、属性访问以及索引指示器访问中通过全权名访问显式接口成员执行体。事实上,显式接口成员执行体只能通过接口的实例,仅仅引用接口的成员名称来访问。

2、显式接口成员执行体不能使用任何访问限制符,也不能加上abstract, virtual, override或static 修饰符。

3、显式接口成员执行体和其他成员有着不同的访问方式。因为不能在方法调用、属性访问以及索引指示器访问中通过全权名访问,显式接口成员执行体在某种意义上是私有的。但它们又可以通过接口的实例访问,也具有一定的公有性质。

4、只有类在定义时,把接口名写在了基类列表中,而且类中定义的全权名、类型和返回类型都与显式接口成员执行体完全一致时,显式接口成员执行体才是有效的,例如:
 
class Shape: ICloneable {
object ICloneable.Clone( ) {…}
int IComparable.CompareTo(object other) {…}
}

使用显式接口成员执行体通常有两个目的:

1、因为显式接口成员执行体不能通过类的实例进行访问,这就可以从公有接口中把接口的实现部分单独分离开。如果一个类只在内部使用该接口,而类的使用者不会直接使用到该接口,这种显式接口成员执行体就可以起到作用。

2、显式接口成员执行体避免了接口成员之间因为同名而发生混淆。如果一个类希望对名称和返回类型相同的接口成员采用不同的实现方式,这就必须要使用到显式接口成员执行体。如果没有显式接口成员执行体,那么对于名称和返回类型不同的接口成员,类也无法进行实现。

下面的定义是无效的,因为Shape 定义时基类列表中没有出现接口IComparable。
 
class Shape: ICloneable
{
object ICloneable.Clone( ) {…}
}
class Ellipse: Shape
{
object ICloneable.Clone( ) {…}
}

在Ellipse 中定义ICloneable.Clone是错误的,因为Ellipse即使隐式地实现了接口ICloneable,ICloneable仍然没有显式地出现在Ellipse定义的基类列表中。

接口成员的全权名必须对应在接口中定义的成员。如下面的例子中,Paint的显式接口成员执行体必须写成IControl.Paint。
 
using System ;
interface IControl
{
 void Paint( ) ;
}
interface ITextBox: IControl
{
 void SetText(string text) ;
}
class TextBox: ITextBox
{
 void IControl.Paint( ) {…}
 void ITextBox.SetText(string text) {…}
}
 
实现接口的类可以显式实现该接口的成员。当显式实现某成员时,不能通过类实例访问该成员,而只能通过该接口的实例访问该成员。显式接口实现还允许程序员继承共享相同成员名的两个接口,并为每个接口成员提供一个单独的实现。

下面例子中同时以公制单位和英制单位显示框的尺寸。Box类继承 IEnglishDimensions和 IMetricDimensions两个接口,它们表示不同的度量衡系统。两个接口有相同的成员名 Length 和 Width。

程序清单1 DemonInterface.cs
 
interface IEnglishDimensions {
float Length ( ) ;
float Width ( ) ;
}
interface IMetricDimensions {
float Length ( ) ;
float Width ( ) ;
}
class Box : IEnglishDimensions, IMetricDimensions {
float lengthInches ;
float widthInches ;
public Box(float length, float width) {
lengthInches = length ;
widthInches = width ;
}
float IEnglishDimensions.Length( ) {
return lengthInches ;
}
float IEnglishDimensions.Width( ) {
return widthInches ; 
}
float IMetricDimensions.Length( ) {
return lengthInches * 2.54f ;
}
float IMetricDimensions.Width( ) {
return widthInches * 2.54f ;
}
public static void Main( ) {
//定义一个实类对象 "myBox"::
Box myBox = new Box(30.0f, 20.0f);
// 定义一个接口" eDimensions"::
IEnglishDimensions eDimensions = (IEnglishDimensions) myBox;
IMetricDimensions mDimensions = (IMetricDimensions) myBox;
// 输出:
System.Console.WriteLine(" Length(in): {0}", eDimensions.Length( ));
System.Console.WriteLine(" Width (in): {0}", eDimensions.Width( ));
System.Console.WriteLine(" Length(cm): {0}", mDimensions.Length( ));
System.Console.WriteLine(" Width (cm): {0}", mDimensions.Width( ));
}
}

输出:Length(in): 30,Width (in): 20,Length(cm): 76.2,Width (cm): 50.8

代码讨论:如果希望默认度量采用英制单位,请正常实现 Length 和 Width 这两个方法,并从 IMetricDimensions 接口显式实现 Length 和 Width 方法:

public float Length( ) {
return lengthInches ;
}
public float Width( ){
return widthInches;
}
float IMetricDimensions.Length( ) {
return lengthInches * 2.54f ;
}
float IMetricDimensions.Width( ) {
return widthInches * 2.54f ;
}

这种情况下,可以从类实例访问英制单位,而从接口实例访问公制单位:
 
System.Console.WriteLine("Length(in): {0}", myBox.Length( )) ;
System.Console.WriteLine("Width (in): {0}", myBox.Width( )) ; 
System.Console.WriteLine("Length(cm): {0}", mDimensions.Length( )) ;
System.Console.WriteLine("Width (cm): {0}", mDimensions.Width( )) ;

2、继承接口实现

接口具有不变性,但这并不意味着接口不再发展。类似于类的继承性,接口也可以继承和发展。

注意:接口继承和类继承不同,首先,类继承不仅是说明继承,而且也是实现继承;而接口继承只是说明继承。也就是说,派生类可以继承基类的方法实现,而派生的接口只继承了父接口的成员方法说明,而没有继承父接口的实现,其次,C#中类继承只允许单继承,但是接口继承允许多继承,一个子接口可以有多个父接口。

接口可以从零或多个接口中继承。从多个接口中继承时,用":"后跟被继承的接口名字,多个接口名之间用","分割。被继承的接口应该是可以访问得到的,比如从private 类型或internal 类型的接口中继承就是不允许的。接口不允许直接或间接地从自身继承。和类的继承相似,接口的继承也形成接口之间的层次结构。

请看下面的例子:
 
using System ;
interface IControl {
void Paint( ) ;
}
interface ITextBox: IControl {
void SetText(string text) ;
}
interface IListBox: IControl {
void SetItems(string[] items) ;
}
interface IComboBox: ITextBox, IListBox { }

对一个接口的继承也就继承了接口的所有成员,上面的例子中接口ITextBox和IListBox都从接口IControl中继承,也就继承了接口IControl的Paint方法。接口IComboBox从接口ITextBox和IListBox中继承,因此它应该继承了接口ITextBox的SetText方法和IListBox的SetItems方法,还有IControl的Paint方法。
一个类继承了所有被它的基本类提供的接口实现程序。

不通过显式的实现一个接口,一个派生类不能用任何方法改变它从它的基本类继承的接口映射。例如,在声明中
 
interface IControl {
void Paint( );
}
class Control: IControl {
public void Paint( ) {...}
}
class TextBox: Control {
new public void Paint( ) {...}
}

TextBox 中的方法Paint 隐藏了Control中的方法Paint ,但是没有改变从Control.Paint 到IControl.Paint 的映射,而通过类实例和接口实例调用Paint将会有下面的影响
 
Control c = new Control( ) ;
TextBox t = new TextBox( ) ;
IControl ic = c ;
IControl it = t ;
c.Paint( ) ; // 影响Control.Paint( ) ;
t.Paint( ) ; // 影响TextBox.Paint( ) ;
ic.Paint( ) ; // 影响Control.Paint( ) ;
it.Paint( ) ; // 影响Control.Paint( ) ;

但是,当一个接口方法被映射到一个类中的虚拟方法,派生类就不可能覆盖这个虚拟方法并且改变接口的实现函数。例如,把上面的声明重新写为
 
interface IControl {
void Paint( ) ;
}
class Control: IControl {
public virtual void Paint( ) {...}
}
class TextBox: Control {
public override void Paint( ) {...}
}

就会看到下面的结果:
 
Control c = new Control( ) ;
TextBox t = new TextBox( ) ;
IControl ic = c ;
IControl it = t ;
c.Paint( ) ; // 影响Control.Paint( );
t.Paint( ) ; // 影响TextBox.Paint( );
ic.Paint( ) ; // 影响Control.Paint( );
it.Paint( ) ; // 影响TextBox.Paint( );

由于显式接口成员实现程序不能被声明为虚拟的,就不可能覆盖一个显式接口成员实现程序。一个显式接口成员实现程序调用另外一个方法是有效的,而另外的那个方法可以被声明为虚拟的以便让派生类可以覆盖它。例如:
 
interface IControl {
 void Paint( ) ;
}
class Control: IControl {
 void IControl.Paint( ) { PaintControl( ); }
 protected virtual void PaintControl( ) {...}
}
class TextBox: Control {
 protected override void PaintControl( ) {...}
}

这里,从Control 继承的类可以通过覆盖方法PaintControl 来对IControl.Paint 的实现程序进行特殊化。

3、重新实现接口

我们已经介绍过,派生类可以对基类中已经定义的成员方法进行重载。类似的概念引入到类对接口的实现中来,叫做接口的重实现(re-implementation)。继承了接口实现的类可以对接口进行重实现。这个接口要求是在类定义的基类列表中出现过的。对接口的重实现也必须严格地遵守首次实现接口的规则,派生的接口映射不会对为接口的重实现所建立的接口映射产生任何影响。

下面的代码给出了接口重实现的例子:
 
interface IControl {
 void Paint( ) ;
 class Control: IControl
 void IControl.Paint( ) {…}
 class MyControl: Control, IControl
 public void Paint( ) {}
}

实际上就是:Control把IControl.Paint映射到了Control.IControl.Paint上,但这并不影响在MyControl中的重实现。在MyControl中的重实现中,IControl.Paint被映射到MyControl.Paint 之上。

在接口的重实现时,继承而来的公有成员定义和继承而来的显式接口成员的定义参与到接口映射的过程。
 
using System ;
interface IMethods {
 void F( ) ;
 void G( ) ;
 void H( ) ;
 void I( ) ;
}
class Base: IMethods {
 void IMethods.F( ) { }
 void IMethods.G( ) { }
 public void H( ) { }
 public void I( ) { }
}
class Derived: Base, IMethods {
 public void F( ) { }
 void IMethods.H( ) { }
}

这里,接口IMethods在Derived中的实现把接口方法映射到了Derived.F,Base.IMethods.G, Derived.IMethods.H, 还有Base.I。前面我们说过,类在实现一个接口时,同时隐式地实现了该接口的所有父接口。同样,类在重实现一个接口时同时,隐式地重实现了该接口的所有父接口。

using System ;
interface IBase {
 void F( ) ;
}
interface IDerived: IBase {
 void G( ) ;
}
class C: IDerived {
 void IBase.F( ) {
 //对F 进行实现的代码…
}
void IDerived.G( ) {
 //对G 进行实现的代码…
}
}
class D: C, IDerived {
 public void F( ) {
 //对F 进行实现的代码…
}
public void G( ) {
 //对G 进行实现的代码…
}
 
}

这里,对IDerived的重实现也同样实现了对IBase的重实现,把IBase.F 映射到了D.F。

4、映射接口

类必须为在基类表中列出的所有接口的成员提供具体的实现。在类中定位接口成员的实现称之为接口映射(interface mapping )。

映射,数学上表示一一对应的函数关系。接口映射的含义也是一样,接口通过类来实现,那么对于在接口中定义的每一个成员,都应该对应着类的一个成员来为它提供具体的实现。

类的成员及其所映射的接口成员之间必须满足下列条件:

1、如果A和B都是成员方法,那么A和B的名称、类型、形参表(包括参数个数和每一个参数的类型)都应该是一致的。

2、如果A和B都是属性,那么A和B的名称、类型应当一致,而且A和B的访问器也是类似的。但如果A不是显式接口成员执行体,A允许增加自己的访问器。

3、如果A和B都是时间那么A和B的名称、类型应当一致。

4、如果A和B都是索引指示器,那么A和B的类型、形参表(包括参数个数和每一个参数的类型)应当一致。而且A和B的访问器也是类似的。但如果A不是显式接口成员执行体,A允许增加自己的访问器。

  那么,对于一个接口成员,怎样确定由哪一个类的成员来实现呢?即一个接口成员映射的是哪一个类的成员?在这里,我们叙述一下接口映射的过程。假设类C实现了一个接口IInterface,Member是接口IInterface中的一个成员,在定位由谁来实现接口成员Member,即Member的映射过程是这样的:

1、如果C中存在着一个显式接口成员执行体,该执行体与接口IInterface 及其成员Member相对应,则由它来实现Member 成员。

2、如果条件(1)不满足,且C中存在着一个非静态的公有成员,该成员与接口成员Member相对应,则由它来实现Member 成员。

3、如果上述条件仍不满足,则在类C定义的基类列表中寻找一个C 的基类D,用D来代替C。

4、重复步骤1-- 3 ,遍历C的所有直接基类和非直接基类,直到找到一个满足条件的类的成员。

5、如果仍然没有找到,则报告错误。

下面是一个调用基类方法来实现接口成员的例子。类Class2 实现了接口Interface1,类Class2 的基类Class1 的成员也参与了接口的映射,也就是说类Class2 在对接口Interface1进行实现时,使用了类Class1提供的成员方法F来实现接口Interface1的成员方法F:
 
interface Interface1 {
 void F( ) ;
}
class Class1 {
 public void F( ) { }
 public void G( ) { }
}
class Class2: Class1, Interface1 {
 new public void G( ) {}
}

注意:接口的成员包括它自己定义的成员,而且包括该接口所有父接口定义的成员。在接口映射时,不仅要对接口定义体中显式定义的所有成员进行映射,而且要对隐式地从父接口那里继承来的所有接口成员进行映射。

在进行接口映射时,还要注意下面两点:

1、在决定由类中的哪个成员来实现接口成员时,类中显式说明的接口成员比其它成员优先实现。

2、使用Private、protected和static修饰符的成员不能参与实现接口映射。例如:
 
interface ICloneable {
 object Clone( ) ;
}
class C: ICloneable {
 object ICloneable.Clone( ) {…}
 public object Clone( ) {…}
}

例子中成员ICloneable.Clone 称为接口ICloneable 的成员Clone 的实现者,因为它是显式说明的接口成员,比其它成员有着更高的优先权。

如果一个类实现了两个或两个以上名字、类型和参数类型都相同的接口,那么类中的一个成员就可能实现所有这些接口成员:
 
interface IControl {
 void Paint( ) ;
}
interface IForm {
 void Paint( ) ;
}
class Page: IControl, IForm {
 public void Paint( ) {…}
}

这里,接口IControl和IForm的方法Paint都映射到了类Page中的Paint方法。当然也可以分别用显式的接口成员分别实现这两个方法:
 
interface IControl {
 void Paint( ) ;
}
interface IForm {
 void Paint( ) ;
}
class Page: IControl, IForm {
 public void IControl.Paint( ) {
 //具体的接口实现代码
}
public void IForm.Paint( ) {
 //具体的接口实现代码
}
}

上面的两种写法都是正确的。但是如果接口成员在继承中覆盖了父接口的成员,那么对该接口成员的实现就可能必须映射到显式接口成员执行体。看下面的例子:

interface IBase {
 int P { get; }
}
interface IDerived: IBase {
 new int P( ) ;
}

接口IDerived从接口IBase中继承,这时接口IDerived 的成员方法覆盖了父接口的成员方法。因为这时存在着同名的两个接口成员,那么对这两个接口成员的实现如果不采用显式接口成员执行体,编译器将无法分辨接口映射。所以,如果某个类要实现接口IDerived,在类中必须至少定义一个显式接口成员执行体。采用下面这些写法都是合理的:
 
//一:对两个接口成员都采用显式接口成员执行体来实现
lass C: IDerived {
 int IBase.P 
 get 
 { //具体的接口实现代码 }
  int IDerived.P( ){
  //具体的接口实现代码 }
 }
//二:对Ibase 的接口成员采用显式接口成员执行体来实现
class C: IDerived {
 int IBase.P
 get {//具体的接口实现代码}
  public int P( ){
  //具体的接口实现代码 }
 }
//三:对IDerived 的接口成员采用显式接口成员执行体来实现
class C: IDerived{
 public int P
 get {//具体的接口实现代码}
 int IDerived.P( ){
 //具体的接口实现代码}
}

另一种情况是,如果一个类实现了多个接口,这些接口又拥有同一个父接口,这个父接口只允许被实现一次。
 
using System ;
interface IControl {
 void Paint( ) ;
 interface ITextBox: IControl {
 void SetText(string text) ;
}
interface IListBox: IControl {
 void SetItems(string[] items) ;
}
class ComboBox: IControl, ITextBox, IListBox {
 void IControl.Paint( ) {…}
 void ITextBox.SetText(string text) {…}
 void IListBox.SetItems(string[] items) {…}
}

上面的例子中,类ComboBox实现了三个接口:IControl,ITextBox和IListBox。如果认为ComboBox不仅实现了IControl接口,而且在实现ITextBox和IListBox的同时,又分别实现了它们的父接口IControl。实际上,对接口ITextBox 和IListBox 的实现,分享了对接口IControl 的实现。

我们对C#的接口有了较全面的认识,基本掌握了怎样应用C#的接口编程,但事实上,C#的不仅仅应用于.NET平台,它同样支持以前的COM,可以实现COM类到.NET类的转换,如C#调用API。欲了解这方面的知识,请看下一节-接口转换。

时间: 2024-10-11 16:12:03

C#的接口基础教程之五 实现接口的相关文章

C#的接口基础教程之四 访问接口

对接口成员的访问 对接口方法的调用和采用索引指示器访问的规则与类中的情况也是相同的.如果底层成员的命名与继承而来的高层成员一致,那么底层成员将覆盖同名的高层成员.但由于接口支持多继承,在多继承中,如果两个父接口含有同名的成员,这就产生了二义性(这也正是C#中取消了类的多继承机制的原因之一),这时需要进行显式的定义: using System ;interface ISequence { int Count { get; set; }}interface IRing { void Count(in

C#的接口基础教程之三 定义接口成员

接口可以包含一个和多个成员,这些成员可以是方法.属性.索引指示器和事件,但不能是常量.域.操作符.构造函数或析构函数,而且不能包含任何静态成员.接口定义创建新的定义空间,并且接口定义直 接包含的接口成员定义将新成员引入该定义空间. 说明: 1.接口的成员是从基接口继承的成员和由接口本身定义的成员. 2.接口定义可以定义零个或多个成员.接口的成员必须是方法.属性.事件或索引器.接口不能包含常数.字段.运算符.实例构造函数.析构函数或类型,也不能包含任何种类的静态成员. 3.定义一个接口,该接口对于

C#的接口基础教程之二 定义接口

定义接口 从技术上讲,接口是一组包含了函数型方法的数据结构.通过这组数据结构,客户代码可以调用组件对象的功能. 定义接口的一般形式为: [attributes] [modifiers] interface identifier [:base-list] {interface-body}[;] 说明: 1.attributes(可选):附加的定义性信息. 2.modifiers(可选): 允许使用的修饰符有 new 和四个访问修饰符.分别是:new.public.protected.interna

C#的接口基础教程之六 接口转换

C#中不仅支持.Net 平台,而且支持COM平台.为了支持 COM和.Net,C# 包含一种称为属性的独特语言特性.一个属性实际上就是一个 C# 类,它通过修饰源代码来提供元信息.属性使 C# 能够支持特定的技术,如 COM 和 .Net,而不会干扰语言规范本身.C# 提供将COM接口转换为 C#接口的属性类.另一些属性类将 COM类转换为C# 类.执行这些转换不需要任何 IDL 或类工厂. 现在部署的任何COM 组件都可以在接口转换中使用.通常情况下,所需的调整是完全自动进行的. 特别是,可以

C#的接口基础教程之七 覆盖虚接口

有时候我们需要表达一种抽象的东西,它是一些东西的概括,但我们又不能真正的看到它成为一个实体在我们眼前出现,为此面向对象的编程语言便有了抽象类的概念.C#作为一个面向对象的语言,必然也会引入抽象类这一概念.接口和抽象类使您可以创建组件交互的定义.通过接口,可以指定组件必须实现的方法,但不实际指定如何实现方法.抽象类使您可以创建行为的定义,同时提供用于继承类的一些公共实现.对于在组件中实现多态行为,接口和抽象类都是很有用的工具. 一个抽象类必须为类的基本类列表中列出的接口的所有成员提供实现程序.但是

Java基础教程(17)--接口

??就像类一样,接口也是引用类型.它可以包含常量,方法签名,默认方法,静态方法和嵌套类型.在接口中,只有默认方法和静态方法有方法体.但不同于类,接口无法实例化,它只能被类实现或被其他接口继承. 一.定义接口 ??接口的定义由修饰符.关键字interface.接口名.extends关键字和若干继承的父接口(如果有的话)以及接口体组成,语法如下(方括号表示可选内容): public interface DoIt [extends Interface1, Interface2] { void doSo

ecshop微信接口基础认识

ecshop微信接口基础认识,当你要学习ecshop和微信整合的时候,你就必须研究ecshop的数据结构对接以及微信数据接口的基本知识.我们知道微信其实就是通过有效的消息推送,用JSON格式的数据或者是XML格式的数据,推送到你的api上面去显示,其实就是一段XML内容.消息推送的话. ecshop和微信对接的基础接口,就是只是包含简单的消息推送接口,以及操作界面的界面定义接口,其他相关关注接口.都需要开通高级接口,论证接口才能做.发送任何消息之前,必须获取token以及验证access_tok

易伟微信公众平台接口傻瓜教程

易伟微信公众平台接口傻瓜教程部分内容:微信接口9超链接.rmvb微信接口8音乐信息.rmvb微信接口7图文信息.rmvb微信接口6关注回复.rmvb微信接口5关键词回复.rmvb微信接口50连闯三关.rmvb微信接口4接口验证.rmvb微信接口49简答题.rmvb微信接口48正则表达式.rmvb微信接口47 微信5.0后变化..rmvb微信接口46自定义菜单.rmvb...微信接口3编辑模式.rmvb微信接口2官方代码.rmvb微信接口1账号注册.rmvb微信接口10图片回复.rmvb 下载地址

ERPSYSTEM开发教程05 框架接口管理

框架接口是采用类厂来管理的 一个接口要被框架管理的实现步骤 首先是接口定义,接口实现类,接口实例创建函数,指定类厂 unit BplOneIntf; {$WEAKPACKAGEUNIT ON} interface type IBplOne=interface ['{E4C1C5FA-C598-4834-9111-26B52634068D}'] function Add(A,B:Integer):integer; function Sub(A,B:Integer):Integer; end; im