Effective C# Item20：明辨接口实现和虚方法重写

    接口实现和虚方法重写看上去很像，它们都可以对定义在另一个类型中的方法进行重新实现，但是，这两种方式有很大的区别。

    我们来看下面的代码，首先定义一个接口。

    public interface  InterfaceA
    {
        void MethodA();
    }

    我们可以采取以下三种方式来实现上述接口InterfaceA。

    /// <summary>
    /// the first way to implement interface, and this is the most common way.
    /// </summary>
     public class BaseClassWithoutVirtual : InterfaceA
    {
        public void MethodA()
        {
            Console.WriteLine("BaseClassWithoutVirtual");
        }
    }

    /// <summary>
    /// the second way to implement interface, define method as virtual.
    /// </summary>
     public class BaseClassWithVirtual : InterfaceA
    {
        public virtual void MethodA()
        {
            Console.WriteLine("BaseClassWithVirtual");
        }
    }

    /// <summary>
    /// the third way to implement interface, define class and method as abstract.
    /// </summary>
     public abstract class BaseClassWithAbstract : InterfaceA
    {
        public abstract void MethodA();
    }

    上面代码中，使用三种方式实现了接口，其中第一种方式是我们最常见的，定义一个类去实现接口，然后分别实现接口中定义的每一个方法、属性、事件或者索引器；第二种方式一般是在编写框架时使用，它在实现接口定义的方法时，将方法声明为virtual，这样子类可以重写这个方法；第三种方式一般也是在编写框架时使用，它将实现接口的类以及接口中的每个方法都声明为abstract，这种类型是不可以实例化的，并且它的所有派生类都必须实现接口中定义的方法。

    下面的代码展示了如何创建上述类的派生类。

    public class SubClassWithoutVirtual : BaseClassWithoutVirtual
    {
        public new void MethodA()
        {
            Console.WriteLine("SubClassWithoutVirtual");
        }
    }

    public class SubClassWithoutVritual2 : BaseClassWithoutVirtual, InterfaceA
    {
        public new void MethodA()
        {
            Console.WriteLine("SubClassWithoutVritual2");
        }
    }

    public class SubClassWithVirtual : BaseClassWithVirtual
    {
        public override void MethodA()
        {
            Console.WriteLine("SubClassWithVirtual");
        }
    }

    public class SubClassWithAbstract : BaseClassWithAbstract
    {
        public override void MethodA()
        {
            Console.WriteLine("SubClassWithAbstract");
        }
    }

    我们来看下面的代码，是对前面提到的所有代码的测试方法。

    private static void Test()
    {
        Console.WriteLine("Show Base Class Info");
        BaseClassWithoutVirtual baseClass1 = new BaseClassWithoutVirtual();
        baseClass1.MethodA();
        BaseClassWithVirtual baseClass2 = new BaseClassWithVirtual();
        baseClass2.MethodA();
        Console.WriteLine();
        Console.WriteLine("Show Sub Class Info Without Virtual");
        SubClassWithoutVirtual subClass1 = new SubClassWithoutVirtual();
        subClass1.MethodA();
        if (subClass1 is InterfaceA)
        {
            (subClass1 as InterfaceA).MethodA();
        }
        if (subClass1 is BaseClassWithoutVirtual)
        {
            (subClass1 as BaseClassWithoutVirtual).MethodA();  
        }
        SubClassWithoutVritual2 subClass2 = new SubClassWithoutVritual2();
        subClass2.MethodA();
        if (subClass2 is InterfaceA)
        {
            (subClass2 as InterfaceA).MethodA();
        }
        if (subClass2 is BaseClassWithoutVirtual)
        {
            (subClass2 as BaseClassWithoutVirtual).MethodA();
        }

        Console.WriteLine();
        Console.WriteLine("Show Sub Class Info With Virtual");
        SubClassWithVirtual subClass3 = new SubClassWithVirtual();
        subClass3.MethodA();
        if (subClass3 is InterfaceA)
        {
            (subClass3 as InterfaceA).MethodA();
        }
        if (subClass3 is BaseClassWithVirtual)
        {
            (subClass3 as BaseClassWithVirtual).MethodA();
        }

        Console.WriteLine();
        Console.WriteLine("Show Sub Class Info With Abstract");
        SubClassWithAbstract subClass4 = new SubClassWithAbstract();
        subClass4.MethodA();
        if (subClass4 is InterfaceA)
        {
            (subClass4 as InterfaceA).MethodA();
        }
        if (subClass4 is BaseClassWithAbstract)
        {
            (subClass4 as BaseClassWithAbstract).MethodA();
        }
    }

    上述代码的运行结果如下图所示。

    关于测试方法，首先，会打印出基类的信息，然后针对每种基类，分别打印派生类的信息，其中，对于每一种派生类，在打印信息时，分为三种情况：1）按照派生类的类型输出；2）按照基类的类型输出；3）按照接口的类型输出。

    我们可以看到对于将基类中方法声明为virtual或者abstract的方式来说，按照派生类的类型和按照基类的类型输出的结果是一致的。

    但是对于最普通的实现接口方式来说，我们定义了两个派生类，第一个派生类直接继承基类，然后通过new关键字重新声明MehtodA方法；第二个派生类直接继承基类，并且实现接口InterfaceA，这个派生类同样也以new关键字重新声明了MethodA方法。但是在执行过程中，对于第一个派生类，将其转换为基类类型或者接口类型后，都会调用基类中的方法；而第二个派生类，在将其转换为基类类型后，会调用基类中的方法，将其转换为接口类型后，就会调用派生类中的方法。

    对于出现上面的结果，如果我们能从对象的运行时类型去考虑，就会发现很容易理解。

    总结：实现接口拥有的选择要比创建和重写虚函数多。我们可以为类层次创建密封的实现、虚实现或者抽象的合约。我们也可以决定派生类如何以及何时修改“基类中实现的接口方法的默认行为”。接口方法不是虚方法，而是一个单独的合约。