七、C# 接口

并非只能通过继承使用多态性，还能通过接口使用它。

和抽象类不同，接口不包含任何实现（方法）。

然后和抽象类相似，接口也定义了一系列成员，调用者可以依赖这些成员来支持一个特定的功能。

 

实现接口的类会使用与被实现的接口相同的签名来定义方法。

 

通过基类来共享成员签名和实现，但通过接口只是共享成员签名，不共享实现。

 

接口的一个关键特征就是它既不包含实现，也不包含数据。

字段不能出现在一个接口中。

但是可以使用属性，由于属性不会包含任何实现作为接口声明的一部分，所以它不会引用一个支持字段。

C#不允许为接口成员使用访问修饰符。所有成员都自动定义为pulbic成员。

 

一旦某个类声明自己要实现一个接口，则该接口的所有成员都必须实现。

接口的一个重要特征在于，它们永远不能被实例化，不能使用new来创建一个接口。

也正是这个原因，接口不能有构造器或终结器。接口实例只适用于实现它们的类型。

除此之外，接口不能包含static成员。接口的一个重要目的就是实现多态性

 

显式接口实现 ，隐式接口实现  

在重写的方法和属性前是否添加接口名。

1、显式成员实现

在实现的方法和属性前加上接口名。

由于显式接口实现直接与接口关联，因此没有必要使用virtual、override或者public来修饰它们。

 

2、隐式成员实现

不在实现的方法和属性前加上接口名。

直接使用方法名和属性名

隐式成员实现必须是public的，除此之外，virtual是可选的，具体取决于派生类是否可以重写实现。

如果去掉virtual，该成员就如同是sealed成员。且override是不允许的。

由于成员的接口声明不包含实现，所以override没有意义。

 

3、显式接口实现与隐式接口实现的比较。

显式接口实现是将“机制方面的考虑”与“模型方面的考虑”分隔开的一种技术。

要求调用者先将对象转换为接口，然后才能认为对象是“可比较”的，可显式地区分你想在什么时候和模型 进行沟通，

以及想在什么时候和实现机制打交道。

以下一些基本的设计原则，可以利用它们来帮助自己选择显式还是隐式实现。

 成员是不是核心的类功能

是：隐式

否：显式

接口成员名作为类成员是否恰当

是：隐式

否：显式

是否已经有一个同名的类成员

是：隐式

否：显式

    class Program
    {
        static void Main(string[] args)
        {
 
            IListTable i;
            Contact c = new Contact();
            c.Name = "name1";
            Console.WriteLine(c.ColnumName);
 
            Appointment a = new Appointment();
            a.Name = "name2";
            Console.WriteLine(((IListTable)a).ColnumName);
 
            Console.ReadLine();
 
        }
    }
 
    interface IListTable
    {
        string ColnumName
        { get; }
    }
    public class Contact : IListTable
    {
        public string Name
        {
            get
            {
                return FirtstName;
            }
            set
            {
                FirtstName = value + " from Contact";
            }
        }
        private string FirtstName;
        //隐式实现
        public string ColnumName
        {
            get { return FirtstName + " ColnumName"; }
            set { FirtstName = value; }
        }
 
 
    }
    public class Appointment : IListTable
    {
        public string Name
        {
            get
            {
                return FirtstName;
            }
            set
            {
                FirtstName = value + " from Appointment";
            }
        }
        private string FirtstName;
 
        //显式实现
        string IListTable.ColnumName
        {
            get { return FirtstName + " ColnumName"; }
            //set { FirtstName = value; }//错误
        }
 
    }

 

 

4、实现类与其接口之间的转型

在实现类的实例中总是包含了接口中的全部成员，所以对象总是能成功转型为接口类型。

从接口类型转为它的实现类，需要执行一次显式的转型。

 

5、接口继承

一个接口可以从另一个接口派生，派生的接口将继承“基接口”的所有成员。

 

在用于显式接口成员实现的一个完全限定的接口成员名称中，必须引用最初声明它的那个接口的名称。

 

 

     class Program
    {
        static void Main(string[] args)
        {
 
 
        }
    }
 
    public interface IReadAbleSettingsProvider
    {
        string GetSetting(string name, string defaultValue);
    }
    public interface ISettingsProvider : IReadAbleSettingsProvider
    {
        void SetSetting(string name, string value);
    }
    class FileSettingsProvider : ISettingsProvider
    {
        public void SetSetting(string name, string value)
        {
            //
        }
        string IReadAbleSettingsProvider.GetSetting(string name, string defaultValue)
        {
            //
            return " ";
        }
    }
 

即使类实现了从基接口派生的一个接口，类仍然可以公开声明两个接口的实现(两个接口都继承实现，放在限定符后面：）

 

    class FileSettingsProvider : ISettingsProvider, IReadAbleSettingsProvider
    {
        public void SetSetting(string name, string value)
        {
            //
        }
        string IReadAbleSettingsProvider.GetSetting(string name, string defaultValue)
        {
            //
            return " ";
        }
    }

 

7、多接口继承

就像类能实现多个接口那样，接口也可以从多个接口继承，而且语法与类的继承和实现的语法是一致的。

 

8、接口上的扩展方法

可以在别的类中为接口添加一个成员方法。（扩展方法必须在静态类中定义，且扩展方法需要static修饰）

 

C#不仅允许为一个特定的对象实例添加扩展方法，还通话为那些对象的一个集合添加扩展方法。对扩展方法的支持是实现

LINQ的基础 。

IEnumerable是所有集合都要实现的基础接口。

通过为IEnumberable定义扩展方法，为所有集合都添加了LINQ支持。

这显著地改变了对象集合的编程方式。

 

    class Program
    {
        static void Main(string[] args)
        {
 
            Contact[] items = new Contact[] { new Contact(), new Contact() };
            for (int i = 0; i < items.Length; i++)
            {
                items[i].ColnumName = "name" + i;
            }
            items.ListColumn();
 
 
 
            Console.ReadLine();
 
        }
    }
 
    interface IListTable
    {
        string ColnumName
        { get; }
    }
    public class Contact : IListTable
    {
        public string Name
        {
            get
            {
                return FirtstName;
            }
            set
            {
                FirtstName = value + " from Contact";
            }
        }
        private string FirtstName;
        //隐式实现
        public string ColnumName
        {
            get { return FirtstName + " ColnumName"; }
            set { FirtstName = value; }
        }
 
 
    }
   
    static class Listable
    {
        public static void ListColumn(this IListTable[] items)
        {
            string headers = "";
            for (int i = 0; i < items.Length; i++)
            {
                headers += items[i].ColnumName + ",";
            }
            Console.WriteLine(headers);
        }
    }

输出：

name0 ColnumName,name1 ColnumName,

 

 

8、通过接口实现多重继承

虽然类只能从一个基类派生，但可以实现任意数量的接口，这有效解决了C#类不支持多重继承的问题。

为此，我们要像上一章讲述的那样使用聚合，但可以稍微改变一下结构，在其中添加一个接口。

需要写代码：

    public class PdaItem
    {
        public PdaItem()
        {
        }
        public PdaItem(DateTime pLastUpdated)
        {
 
            LastUpdated = pLastUpdated;
        }
        public DateTime LastUpdated { set; get; }
    }
    interface IPerson
    {
         string FirstName { set; get; }
         string LastName { set; get; }
    }
    public class Person : IPerson
    {
        public string Address { set; get; }
        public string Phone { set; get; }
 
        public string FirstName { set; get; }
        public string LastName { set; get; }
    }
    //使用聚合(实现继承Person 和 PdaItem 两个类，并将方法和属性放到接口当中
    public class Contact : PdaItem, IPerson
    {
        private Person _Person;
        public Person person
        {
            set
            {
                _Person = value;
            }
            get
            {
                return _Person;
            }
        }
        public string FirstName
        {
            get
            {
                return _Person.FirstName;
            }
            set
            {
                _Person.FirstName = value;
            }
        }
        public string LastName
        {
            get
            {
                return _Person.LastName;
            }
            set
            {
                _Person.LastName = value;
            }
        }
 
    }

    //IPerson 确保Person的成员和复制到Contact的成员具有一致的签名，然而，这个实现仍然没有作到"多重继承"真正同义

    //，因为添加到Person的新成员不会同时添加到Contact上（以上的是接口的实现没有带过来，也不能进行重写，只能利用继承这个接口，实现这个接口，重写那两个属性）。

    //如果被实现的成员是方法（不是属性），那么有一个办法可以对此进行改进。具体地说，就是为从第二个基类"派生"的附加功能定义接口扩展方法。

    //例如，IPerson上的一个扩展方法可以提供一个名为VerifyCredentials()的方法。这样一来，实现了IPerson的所有类（即使IPerson接口没有成员，只用扩展方法）

    //都会有VerifyCredentials()的一个默认实现。这之所以可行，完全是多态性和重写的功能。之所以支持重写，是因为一个方法的任何实例实现都要优先

    //具有相同静态签名的一个扩展方法。

9、版本控制

需要对程序增加功能时，不应该修改原来的接口，而是再定义一个接口，然后继承原来的接口，新接口上添加功能定义，

再使需要增加功能的类实现该接口。

 

10、接口与类的比较 

接口引入 了另一个类别的数据类型（它们是少数不对终极基类System.Object进行扩展的类型之一，此外还有指针类型和类型参数类型）

 

然后，和类不同的是，接口永远不能实例化。要访问一个接口p痊，只能通过对实现了接口的一个对象的引用来进行。

不能为接口使用new运算。所以，接口不能包含任何构造器或终结器，除此之外，静态成员在接口上是不允许的。

 

接口近似于抽象类，两者具有一些共同的特点。