C# - 接口

 一、接口的作用实例

接口可以统一名称，统一功能，统一调用，主要是用来描述类的功能。

      C#接口的作用是什么呢？首先我们来看看什么是C#接口，C#接口是一个让很多初学C#者容易迷糊的东西，用起来好像很简单，定义接口，里面包含方法，但没有方法具体实现的代码，然后在继承该接口的类里面要实现接口的所有方法的代码，但没有真正认识到接口的作用的时候就觉得用接口是多此一举，当然你这样想那是绝对绝对错误的，比尔盖茨的微软请的员工都是比盖茨还聪明的人，他们的C#能添这样的多足吗？！关于接口的作用，网上有一位就真的深入浅出给我们做了很好理解的分析。

public interface IBark

{

      void Bark(); 

}

再定义一个类,继承于IBark,并且必需实现其中的Bark()方法

public class Dog:IBark 

{

      public Dog()

      {

      }

      public void Bark()

      {

         Consol.write("汪汪");

      }

}

然后,声明Dog的一个实例,并调用Bark()方法

Dog 旺财=new Dog();

旺财.Bark();

试想一样,若是想调用Bark()方法,只需要在Dog()中声明这样的一个方法不就行了吗,干什么还要用接口呢.因为接口中并没有Bark()具体实现.真的实现还是要在Dog()中.那么使用接口不是多此一举吗?

还有人是这样说的:从接口的定义方面来说,接口其实就是类和类之间的一种协定,一种约束.还拿上面的例子来说.所有继承了IBark接口的类中必需实现Bark()方法.那么从用户(使用类的用户)的角度来说,如果他知道了某个类是继承于IBark接口,那么他就可以放心大胆的调用Bark()方法,而不用管Bark()方法具体是如何实现的.比如,我们另外写了一个类.

public class Cat:IBark 

{

     public Cat()

     {

     }

     public void Bark()

     {

        Consol.write("喵喵");

     } 

}

当用户用到Cat类或是Dog类的时候,知道他们继承于IBark,那么不用管类里的具体实现,而就可以直接调用Bark()方法,因为这两个类中肯定有关于Bark()方法的具体实现.

如果我们从设计的角度来看.一个项目中用若干个类需要去编写,由于这些类比较复杂,工作量比较大,这样每个类就需要占用一个工作人员进行编写.比如A程序员去定Dog类,B程序员去写Cat类.这两个类本来没什么联系的,可是由于用户需要他们都实现一个关于"叫"的方法.这就要对他们进行一种约束.让他们都继承于IBark接口,目的是方便统一管理.另一个是方便调用.当然了,不使用接口一样可以达到目的.只不过这样的话,这种约束就不那么明显,如果这样类还有Duck类等等,比较多的时候难免有人会漏掉这样方法.所以说还是通过接口更可靠一些,约束力更强一些.

 

二、接口的定义

接口使用 interface 关键字进行定义，如下面的示例所示：

interface IEquatable<T>

{

    bool Equals(T obj);

}

接口描述的是可属于任何类或结构的一组相关功能。接口可由方法、属性、事件、索引器或这四种成员类型的任意组合构成。接口不能包含字段。接口成员一定是公共的。

当类或结构继承接口时，意味着该类或结构为该接口定义的所有成员提供实现。接口本身不提供类或结构能够以继承基类功能的方式继承的任何功能。但是，如果基类实现接口，派生类将继承该实现。

类和结构可以按照类继承基类或结构的类似方式继承接口，但有两个例外：

·类或结构可继承多个接口。

·类或结构继承接口时，仅继承方法名称和签名，因为接口本身不包含实现。

例如：

public class Car : IEquatable<Car>

{

    public string Make {get; set;}

    public string Model { get; set; }

    public string Year { get; set; }

 

    // Implementation of IEquatable<T> interface

    public bool Equals(Car car)

    {

        if (this.Make == car.Make &&

            this.Model == car.Model &&

            this.Year == car.Year)

        {

            return true;

        }

        else

            return false;

    }

}

若要实现接口成员，类中的对应成员必须是公共的、非静态的，并且与接口成员具有相同的名称和签名。类的属性和索引器可以为接口上定义的属性或索引器定义额外的访问器。例如，接口可以声明一个带有 get 访问器的属性，而实现该接口的类可以声明同时带有 get 和 set 访问器的同一属性。但是，如果属性或索引器使用显式实现，则访问器必须匹配。

接口和接口成员是抽象的；接口不提供默认实现。

IEquatable<T> 接口向对象的用户宣布该对象可以确定其是否与同一类型的其他对象相等，而接口的用户不需要知道相关的实现方式。

接口可以继承其他接口。类可以通过其继承的基类或接口多次继承某个接口。在这种情况下，如果将该接口声明为新类的一部分，则该类只能实现该接口一次。如果没有将继承的接口声明为新类的一部分，其实现将由声明它的基类提供。基类可以使用虚拟成员实现接口成员；在这种情况下，继承接口的类可通过重写虚拟成员来更改接口行为。

接口具有下列属性：

·接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。

·不能直接实例化接口。

·接口可以包含事件、索引器、方法和属性。

·接口不包含方法的实现。

·类和结构可从多个接口继承。

·接口自身可从多个接口继承。

 

三、显式接口实现

如果类实现两个接口，并且这两个接口包含具有相同签名的成员，那么在类中实现该成员将导致两个接口都使用该成员作为它们的实现。例如：

interface IControl

{

    void Paint();

}

interface ISurface

{

    void Paint();

}

class SampleClass : IControl, ISurface

{

    // Both ISurface.Paint and IControl.Paint call this method.

    public void Paint()

    {

    }

}

然而，如果两个接口成员执行不同的函数，那么这可能会导致其中一个接口的实现不正确或两个接口的实现都不正确。可以显式地实现接口成员 -- 即创建一个仅通过该接口调用并且特定于该接口的类成员。这是使用接口名称和一个句点命名该类成员来实现的。例如:

public class SampleClass : IControl, ISurface

{

    void IControl.Paint()

    {

        System.Console.WriteLine("IControl.Paint");

    }

    void ISurface.Paint()

    {

        System.Console.WriteLine("ISurface.Paint");

    }

}

类成员 IControl.Paint 只能通过 IControl 接口使用，ISurface.Paint 只能通过 ISurface 使用。两个方法实现都是分离的，都不可以直接在类中使用。例如：

SampleClass obj = new SampleClass();

//obj.Paint();  // Compiler error.

IControl c = (IControl)obj;

c.Paint();  // Calls IControl.Paint on SampleClass.

ISurface s = (ISurface)obj;

s.Paint(); // Calls ISurface.Paint on SampleClass.

显式实现还用于解决两个接口分别声明具有相同名称的不同成员（如属性和方法）的情况：

interface ILeft

{

    int P { get;}

}

interface IRight

{

    int P();

}

为了同时实现两个接口，类必须对属性 P 和/或方法 P 使用显式实现以避免编译器错误。例如：

class Middle : ILeft, IRight

{

    public int P() { return 0; }

    int ILeft.P { get { return 0; } }

}

 

四、如何：显式实现接口成员

声明一个 接口 IDimensions 和一个类 Box，该类显式实现接口成员 getLength 和 getWidth。通过接口实例 dimensions 访问这些成员。

interface IDimensions

{

    float getLength();

    float getWidth();

}

class Box : IDimensions

{

    float lengthInches;

    float widthInches;

 

    Box(float length, float width)

    {

        lengthInches = length;

        widthInches = width;

    }

    // Explicit interface member implementation:

    float IDimensions.getLength()

    {

        return lengthInches;

    }

    // Explicit interface member implementation:

    float IDimensions.getWidth()

    {

        return widthInches;

    }

 

    static void Main()

    {

        // Declare a class instance box1:

        Box box1 = new Box(30.0f, 20.0f);

 

        // Declare an interface instance dimensions:

        IDimensions dimensions = (IDimensions)box1;

 

        // The following commented lines would produce compilation

        // errors because they try to access an explicitly implemented

        // interface member from a class instance:                  

        //System.Console.WriteLine("Length: {0}", box1.getlength());

        //System.Console.WriteLine("Width: {0}", box1.getwidth());

 

        // Print out the dimensions of the box by calling the methods

        // from an instance of the interface:

        System.Console.WriteLine("Length: {0}", dimensions.getLength());

        System.Console.WriteLine("Width: {0}", dimensions.getWidth());

    }

}

/* Output:

    Length: 30

    Width: 20

*/

可靠编程

请注意 Main 方法中下列代码行被注释掉，因为它们将产生编译错误。显式实现的接口成员不能从类实例访问：

//System.Console.WriteLine("Length: {0}", box1.getlength());

//System.Console.WriteLine("Width: {0}", box1.getwidth());

还请注意，Main 方法中的下列代码行成功输出框的尺寸，因为这些方法是从接口实例调用的：

System.Console.WriteLine("Length: {0}", dimensions.getLength());

System.Console.WriteLine("Width: {0}", dimensions.getWidth());

 

五、如何：使用继承显式实现接口成员

      显式接口实现还允许程序员实现具有相同成员名称的两个接口，并为每个接口成员各提供一个实现。本示例同时以公制单位和英制单位显示框的尺寸。Box 类实现 IEnglishDimensions 和 IMetricDimensions 两个接口，它们表示不同的度量系统。两个接口有相同的成员名称 Length 和 Width。

// Declare the English units interface:

interface IEnglishDimensions

{

    float Length();

    float Width();

}

 

// Declare the metric units interface:

interface IMetricDimensions

{

    float Length();

    float Width();

}

 

// Declare the Box class that implements the two interfaces:

// IEnglishDimensions and IMetricDimensions:

class Box : IEnglishDimensions, IMetricDimensions

{

    float lengthInches;

    float widthInches;

 

    public Box(float length, float width)

    {

        lengthInches = length;

        widthInches = width;

    }

 

    // Explicitly implement the members of IEnglishDimensions:

    float IEnglishDimensions.Length()

    {

        return lengthInches;

    }

 

    float IEnglishDimensions.Width()

    {

        return widthInches;

    }

 

    // Explicitly implement the members of IMetricDimensions:

    float IMetricDimensions.Length()

    {

        return lengthInches * 2.54f;

    }

 

    float IMetricDimensions.Width()

    {

        return widthInches * 2.54f;

    }

 

    static void Main()

    {

        // Declare a class instance box1:

        Box box1 = new Box(30.0f, 20.0f);

 

        // Declare an instance of the English units interface:

        IEnglishDimensions eDimensions = (IEnglishDimensions)box1;

 

        // Declare an instance of the metric units interface:

        IMetricDimensions mDimensions = (IMetricDimensions)box1;

 

        // Print dimensions in English units:

        System.Console.WriteLine("Length(in): {0}", eDimensions.Length());

        System.Console.WriteLine("Width (in): {0}", eDimensions.Width());

 

        // Print dimensions in metric units:

        System.Console.WriteLine("Length(cm): {0}", mDimensions.Length());

        System.Console.WriteLine("Width (cm): {0}", mDimensions.Width());

    }

}

/* Output:

    Length(in): 30

    Width (in): 20

    Length(cm): 76.2

    Width (cm): 50.8

*/

可靠编程

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

// Normal implementation:

public float Length()

{

    return lengthInches;

}

public float Width()

{

    return widthInches;

}

 

// Explicit implementation:

float IMetricDimensions.Length()

{

    return lengthInches * 2.54f;

}

float IMetricDimensions.Width()

{

    return widthInches * 2.54f;

}

这种情况下，可以从类实例访问英制单位，而从接口实例访问公制单位：

public static void Test()

{

    Box box1 = new Box(30.0f, 20.0f);

    IMetricDimensions mDimensions = (IMetricDimensions)box1;

 

    System.Console.WriteLine("Length(in): {0}", box1.Length());

    System.Console.WriteLine("Width (in): {0}", box1.Width());

    System.Console.WriteLine("Length(cm): {0}", mDimensions.Length());

    System.Console.WriteLine("Width (cm): {0}", mDimensions.Width());

}

 

六、接口属性

可以在接口上声明属性。以下是接口索引器访问器的示例：

public interface ISampleInterface

{

    // Property declaration:

    string Name

    {

        get;

        set;

    }

}

接口属性的访问器不具有体。因此，访问器的用途是指示属性是否为读写、只读或只写。

示例

在此例中，接口 IEmployee 具有读写属性 Name 和只读属性 Counter。Employee 类实现 IEmployee 接口并使用这两种属性。程序读取新雇员的姓名和雇员的当前编号，并显示雇员姓名和计算所得的雇员编号。

可以使用属性的完全限定名，它引用声明成员的接口。例如：

string IEmployee.Name

{

    get { return "Employee Name"; }

    set { }

}

这称为显式接口实现。例如，如果 Employee 类实现两个接口 ICitizen 和 IEmployee，并且两个接口都具有 Name 属性，则需要显式接口成员实现。即，如下属性声明：

string IEmployee.Name

{

    get { return "Employee Name"; }

    set { }

}

在 IEmployee 接口上实现 Name 属性，而下面的声明：

string ICitizen.Name

{

    get { return "Citizen Name"; }

    set { }

}

在 ICitizen 接口上实现 Name 属性。

interface IEmployee

{

    string Name

    {

        get;

        set;

    }

 

    int Counter

    {

        get;

    }

}

 

public class Employee : IEmployee

{

    public static int numberOfEmployees;

 

    private string name;

    public string Name  // read-write instance property

    {

        get

        {

            return name;

        }

        set

        {

            name = value;

        }

    }

 

    private int counter;

    public int Counter  // read-only instance property

    {

        get

        {

            return counter;

        }

    }

 

    public Employee()  // constructor

    {

        counter = ++counter + numberOfEmployees;

    }

}

 

class TestEmployee

{

    static void Main()

    {

        System.Console.Write("Enter number of employees: ");

        Employee.numberOfEmployees = int.Parse(System.Console.ReadLine());

 

        Employee e1 = new Employee();

        System.Console.Write("Enter the name of the new employee: ");

        e1.Name = System.Console.ReadLine();

 

        System.Console.WriteLine("The employee information:");

        System.Console.WriteLine("Employee number: {0}", e1.Counter);

        System.Console.WriteLine("Employee name: {0}", e1.Name);

    }

}

//210

//Hazem Abolrous

 

示例输出

Enter number of employees: 210

Enter the name of the new employee: Hazem Abolrous

The employee information:

Employee number: 211

Employee name: Hazem Abolrous

 

七、接口中的索引器

索引器可在接口上声明。接口索引器的访问器与类索引器的访问器具有以下方面的不同：

·接口访问器不使用修饰符。

·接口访问器没有体。

因此，访问器的用途是指示索引器是读写、只读还是只写。

以下是接口索引器访问器的示例：

public interface ISomeInterface

{

    //...

 

    // Indexer declaration:

    string this[int index]

    {

        get;

        set;

    }

}

一个索引器的签名必须区别于在同一接口中声明的其他所有索引器的签名。

示例：

下面的示例显示如何实现接口索引器。

// Indexer on an interface:

public interface ISomeInterface

{

    // Indexer declaration:

    int this[int index]

    {

        get;

        set;

    }

}

 

// Implementing the interface.

class IndexerClass : ISomeInterface

{

    private int[] arr = new int[100];

    public int this[int index]   // indexer declaration

    {

        get

        {  

            // The arr object will throw IndexOutOfRange exception.

            return arr[index];

        }

        set

        {              

            arr[index] = value;               

        }

    }

}

 

class MainClass

{

    static void Main()

    {

        IndexerClass test = new IndexerClass();

        // Call the indexer to initialize the elements #2 and #5.

        test[2] = 4;

        test[5] = 32;

        for (int i = 0; i <= 10; i++)

        {

            System.Console.WriteLine("Element #{0} = {1}", i, test[i]);

        }

 

        // Keep the console window open in debug mode.

        System.Console.WriteLine("Press any key to exit.");

        System.Console.ReadKey();

    }

}

/* Output:

    Element #0 = 56.2

    Element #1 = 56.7

    Element #2 = 56.5

    Element #3 = 58.3

    Element #4 = 58.8

    Element #5 = 60.1

    Element #6 = 65.9

    Element #7 = 62.1

    Element #8 = 59.2

    Element #9 = 57.5

*/

      在上例中，可以通过使用接口成员的完全限定名来使用显式接口成员实现。例如：

public string ISomeInterface.this

{

}

      但是，只有当类使用同一索引器签名实现一个以上的接口时，为避免多义性才需要使用完全限定名。例如，如果 Employee 类实现的是两个接口 ICitizen 和 IEmployee，并且这两个接口具有相同的索引器签名，则必须使用显式接口成员实现。即，以下索引器声明：

public string IEmployee.this

{

}

在 IEmployee 接口上实现索引器，而以下声明：

public string ICitizen.this

{

}