七、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运算。所以，接口不能包含任何构造器或终结器，除此之外，静态成员在接口上是不允许的。

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