C# Interface的使用方法探讨

　　接口是把公共实例（非静态）的方法和属性结合起来，以封装特定功能的一个集合，一旦定义了接口，就可以在类中使用实现接口中的所有成员，接口可以看作创建者和使用者之间的契约，一旦实现了接口，就不要轻易变动（如果需要变更接口，一般需要继承旧接口并且添加版本号）。我们知道在C++里面是有纯虚函数，虚继承和多重继承的，C#里面为了简化C++的这些复杂的设施，引出了接口这个概念。

 

C#接口和类的区别：

---

1. 不允许使用访问修饰符（public, private, protected,或者internal）修饰接口成员，所有的接口成员都是公共的。

2. 接口成员不能包含代码体

3. 接口不能定义字段成员

4. 不能用关键字static，virtual，abstract或者sealed来定义接口成员

5. 类型定义成员是禁止的。

 

 

实现C#隐式接口：

---

　　其实接口和C++中那种头文件声明一个接口然后在cpp里面实现一遍那种做法看上去没有什么区别，只是C#把这个做的更纯粹（自从学了C#我越发觉得C++真是一门很啰嗦的语言）。如果一个类继承了一个接口，那么其对接口内的内容的实现可以在当前类实现，也可以在当前类的基类实现：

public class FuckBase
{
      public void FuckSomething(int fuck)
       {

       }
}

public class Fuck :FuckBase, A
{
        public int AInt
        {
            get;
            private set;
        }

        public void DoSomething()
        {

        }
}

　　比如上面这个例子，就在基类中实现了接口，如果要隐藏基类的接口，可以直接new一下。

　　当然了，接口是可以继承的，比如：

public interface A
{
    void DoSomething();
}

public interface DeriveedA: A
{
    new void DoSomething();
}

　　

　　在C#的接口中可以定义属性，比如：

public interface DeriveedA: A
{
    new void DoSomething();
    int AInt { get; set; }
}

　　

　　这样定义了以后，继承了DeriveedA的类必须实现AInt的get和set两个属性访问器了，并且都必须是public，有时候我们需要降低写访问器的访问权限，我们可以不在接口中定义set属性访问器，这样我们可以在类中实现有特殊访问属性的set属性访问器了，比如：

public interface DeriveedA: A
{
    new void DoSomething();
    int AInt { get; }
}

public class Fuck : DeriveedA
{
    public int AInt
    {
        get;
        private set;//当然了这里也可以是protected
    }

    public void DoSomething()
    {

    }
}

 

实现C#显式接口：

---

       上面的实现都属于C#的接口的隐式实现，那显式实现是什么东西？看下面的例子：

public class Starter
{
    /// <summary>
    /// 程序入口点
    /// </summary>
    /// <param name="args"></param>
    public static void Main(string[] args)
    {
        Fuck test = new Fuck();
    }
}

public interface IFuck
{
    void Haha();
}

public class Fuck :IFuck
{
    void IFuck.Haha()
    {

    }
}

　

　　这个时候如果我们直接使用test对象，是无法调用Haha这个方法的，因为如果一个类显示实现了一个接口，那么这个接口函数将是private的，外部无法直接调用这个函数，除非把类显式转换为接口：

public class Starter
{
    /// <summary>
    /// 程序入口点
    /// </summary>
    /// <param name="args"></param>
    public static void Main(string[] args)
    {
        Fuck test = new Fuck();
        IFuck interfaceFuck = (IFuck)test;
        interfaceFuck.Haha();//这个时候相当于可以使用test.Haha这个方法了
    }
}

public interface IFuck
{
    void Haha();
}

public class Fuck :IFuck
{
    void IFuck.Haha()//注意显式实现接口不能带访问修饰符
    {

    }
}

　　

　　可能有人问为什么不把接口方法的实现定义为private，这个在C#里面是不允许的，如果一个类实现了一个接口（隐式实现），那么这个接口不能是private或者是protected的，必须是public的（必须是公共接口），这其实理解起来很自然，因为往往我们把一个类继承一个接口，就是需要这个接口所声明的方法。

　　那么为什么还需要显式实现呢？从上面的例子我们可以看到，如果显式实现了一个接口，那么直接通过类来访问接口的方法是不行的，必须是显式转换为接口才可以访问，这就相当于了一个private的功能，比如我继承了一个IList<T>，我可能只需要IList<T>接口的一部分，那么我可以把我需要的部分隐式实现，不需要的部分显式实现，那么这个时候我既可以隐藏我不需要用到的方法，也可以把它当成一个IList<T>来用（用的时候转换为接口就好了）。这在软件工程里面是很常见的，有些时候我们写了一个类让框架来绑定，但是我们不想有些接口被误用，但是又想我们可以把它当做实现了这个接口的类型来用的时候，这样的做法就是最好的。非常符合面向对象的思想。

 

　　再举几个可以用显示接口的例子。

　　比如现在我有一个航空公司，公司里面有很多航班，但是其中B航班和C航班是特价航班，换句话说，就是航班之间的价格定价是不一样的，我们先假定一下所有航班的差别就是价格。

　　那么我们很容易想到我们可以实现一个这样的航班类，但是我们如果要查询价格的时候，当我们显示查询B，C航班价格时，使用其各自特殊的计算方法，其他航班则选择统一的方法，在C#里面我们可以这样实现：

public class Starter
{
    /// <summary>
    /// 程序入口点
    /// </summary>
    /// <param name="args"></param>
    public static void Main(string[] args)
    {
        Flys fly = new Flys();
        IFlyB flyB = fly;
        flyB.Cost();//计算航班B的价格

        IFlyC flyC = fly;
        flyC.Cost();//计算航班C的价格

        fly.Cost();//计算普通航班的价格

        Console.ReadKey();
    }
}

public interface IFlyB
{
    void Cost();
}

public interface IFlyC
{
    void Cost();
}

public class Flys :IFlyB,IFlyC
{
    public void Cost()
    {
        Console.WriteLine("Other fly");
    }

    void IFlyB.Cost()
    {
        Console.WriteLine("Fly B");
    }

    void IFlyC.Cost()
    {
        Console.WriteLine("Fly C");
    }
}

　　

　　当然了，如果看过Effective C++的人已经知道我说的就是这本书上的例子，那么在C++的实现方法可以是实现一个Flys的虚基类，把Cost设为虚函数，然后派生出FlyC和FlyB，重写Cost，其他航班就显式使用虚函数的默认方法：

class Flys
{
public:
    virtual void cost()const =
    {
        std::cout << "Other fly" << std::endl;
    }
};

class FlyB :public Flys
{
public:
    void cost()const override
    {
        std::cout << "FlyB" << std::endl;
    }
};

class FlyC :public Flys
{
public:
    void cost()const override
    {
        std::cout << "FlyC" << std::endl;
    }
};

class OtherFly :public Flys
{
public:
    void cost()const override
    {
        Flys::cost();
    }
};

　　

　　这是一个C++的Best practice，因为这样写以后我们每次定义一种Fly都必须提供Fly的定义，可以使用默认定义，减少了程序员犯错的可能，C++可以这样写是因为C++的纯虚函数是一个很奇葩的东西，本身它应该是类似于C#的interface才对，但是却有了默认行为。

 

　　第二个例子是，当我有两个接口，但是在一个在一个接口里面声明了名为Item的属性，另一个接口声明了Item的一个方法，如果我一个类要同时继承这两个接口，怎么办呢？

public interface IOne
{
    int Item { get; set; }
}

public interface ITwo
{
    int Item();
}

public class Hey : IOne, ITwo
{
    public int Item { get; set;}

    public int Item()
    {
        throw new NotImplementedException();
    }
}

　　

　　当你写出上面的代码的时候，编译器会报错，Item具有二义性，那么这个时候你必须显式实现一个接口：

public interface IOne
{
    int Item { get; set; }
}

public interface ITwo
{
    int Item();
}

public class Hey : IOne, ITwo
{
    public int Item { get; set;}

    int ITwo.Item()
    {

    }
}

　　

　　第三种情况就是刚才说的，当有些接口你不想让别人使用，但是你却想定义自己的版本的时候，比如你想实现一个List，并且想获得一个当Remove的时候还可以获取到节点的一个方法，但是IList<T>接口并没有声明这个方法，于是你可以这样写：

public class ListNode<T> : IList<T>
{
    public T RemoveAt(int index)
    {

    }

    void IList<T>.RemoveAt(int index)
    {

    }
}

　　

　　这样就实现了我们的想法，而且接口还不容易被误用。甚至你还可以在显式实现的接口void IList<T>.RemoveAt(int index)里面抛出异常，说明不支持这种方法。