virtual和override

偶然间看到的题，借此记录。

 class Program
    {
        static void Main(string[] args)
        {
            D d = new D();  //第一个D是申明类，第二个D是实例类
            A a = d;
            B b = d;
            C c = d;

            a.F();
            b.F();
            c.F();
            d.F();
        }
        class A
        {
            public virtual void F() { Console.WriteLine("A.F"); }
        }
        class B : A
        {
            public override void F() { Console.WriteLine("B.F"); }

        }
        class C : B
        {
            public virtual void F() { Console.WriteLine("C.F"); }

        }
        class D : C
        {
            public override void F() { Console.WriteLine("D.F"); }

        }
    }

输出结果：

下面记录一下解题步骤：

a.F();  >>>  1. 检查申明类A 2. 是虚方法 3. 继续检查实例类D 4. 有重写，但是相对于类A来说Fun()在类C中被new 过，根据口诀“new则看类型，override只管新” 5. 继续检查父类B 6. 类B中override了父类A的 Fun() 7. 执行类B中的Fun()，输出B.F

b.F();  >>>  1. 检查申明类B 2. 不是虚方法 3. 直接执行类B中的Fun()，输出B.F

c.F();  >>>  1. 检查申明类C 2. 是虚方法 3. 继续检查实例类D 4. 有重写，类D重写了类C中的Fun()，根据口诀“new则看类型，override只管新” 5. 执行类D中的Fun()，输出D.F

d.F();  >>>  1. 检查申明类D 2. 不是虚方法 3. 直接执行类D中的Fun()，输出D.F

摘用一下别人特别好的总结：

具体的检查的流程如下

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

在上面的规则中，可以看到，如果子类没有override的修饰，那么就算父类是virtual的方法，子类的方法也无法被调用，而会去它的父类中找override的方法，直到找到祖先类。所以在面向对象的开发过程中，如果要实现Dependency Injection、IoC等设计模式，就必须非常留意类设计中继承方法的声明，否则很可能导致实际的程序运行与预期不符。

引用：https://www.cnblogs.com/yanyao/p/4830768.html