virtual 使用

c#的方法，默认为非虚方法，如果一个方法被声明为 virtual （虚方法），则继承该方法的任何类都可以实现它自己的版本。

public class BaseEngineer
{
    public virtual void Work()
    {
        Console.WriteLine("BaseEngineer.Work");
    }
}

virtual 方法可以通过 Override 和 new 关键字来进行版本控制、重写.

Override 关键字

Override 用来重写基类的虚方法。如下例子中，override 关键字可以确保派生类 JuniorEngineer / SeniorEngineer 的任何对象将使用 work 的派生类版本，同时又可以通过 base 关键字访问基类的版本。

public class JuniorEngineer : BaseEngineer
{
    public override void Work()
    {
        base.Work();
        Console.WriteLine("=>JuniorEngineer.Work");
    }
}
public class SeniorEngineer : BaseEngineer
{
    public override void Work()
    {
        base.Work();
        Console.WriteLine("=>SeniorEngineer.Work");
    }
}

var juniorEngineer = new JuniorEngineer();
juniorEngineer.Work();

var seniorEngineer = new SeniorEngineer();
seniorEngineer.Work();
----------------------Output---------------------------
BaseEngineer.Work
=>JuniorEngineer.Work
BaseEngineer.Work
=>SeniorEngineer.Work

New 关键字

派生类的方法前面带有 new 关键字，则该方法被定义为独立于基类中的方法，用 new 关键字可以隐藏基类中的虚方法。

假如派生类中的方法前面没有 new / override 关键字，那么编译期会发出 Warning，并将该方法作为有 new 关键字去执行。

public class SuperEngineer : BaseEngineer
{
    public new void Work()
    {
        base.Work();
        Console.WriteLine("=>Eat a bug!");
        Console.WriteLine("=>Create lots of bugs!");
    }
}

var superEngineer = new SuperEngineer();
superEngineer.Work();
----------------------Output---------------------------
BaseEngineer.Work
=>Eat a bug!
=>Create lots of bugs!

何时使用 Override / New 关键字？

从上面可以看到，无论使用 Override / New 中哪一个，派生类的实例似乎都可以重新定义方法内容，也可以调用base的方法，那么为何要有2个关键字呢？

上面的例子，我们稍微改动一点，所有 override / new 的实现中，都不再调用 base 的虚方法，并通过基类访问派生类实例：

public class JuniorEngineer : BaseEngineer
{
    public override void Work()
    {
        Console.WriteLine("=>JuniorEngineer.Work");
    }
}
public class SeniorEngineer : BaseEngineer
{
    public override void Work()
    {
        Console.WriteLine("=>SeniorEngineer.Work");
    }
}
public class SuperEngineer : BaseEngineer
{
    public new void Work()
    {
        Console.WriteLine("=>Eat a bug!");
        Console.WriteLine("=>Create lots of bugs!");
    }
}

var enginners = new List<BaseEngineer>
{
    juniorEngineer,
    seniorEngineer,
    superEngineer
};

foreach (var enginner in enginners)
{
    enginner.Work();
}

--------------Output----------------------
=>JuniorEngineer.Work
=>SeniorEngineer.Work
BaseEngineer.Work

Junior / Senior 都如期工作，调用了派生类中的方法，而最后的 SuperEngineer 并没有执行派生类的方法，而是执行了基类的虚方法。

因为数组的类型为 BaseEngine，且派生类 SuperEngineer 使用了 new 关键字重新定义方法，因此最终执行的是基类虚方法。

不要在构造函数里调用虚函数

这一条是引自《Effective c#》，在构建对象的过程中调用虚方法会使程序表现出奇怪的行为，因为这个时候对象并没有完全构造好。将书中的例子改的更为详尽一些：

public class VirtualB
{
    protected VirtualB()
    {
        Console.WriteLine("VritualB constructor start");
        VFunc();
        Console.WriteLine("VritualB constructor end");
    }

    protected virtual void VFunc()
    {
        Console.WriteLine("VirtualB.VFunc");
    }
}
public class Derived : VirtualB
{
    private readonly string msg = "Set by initializer";

    public Derived(string msg)
    {
        Console.WriteLine("Derived constructor start");
        this.msg = msg;
        VFunc();
        Console.WriteLine("Derived constructor end");
    }

    protected override void VFunc()
    {
        Console.WriteLine($"Derived: {msg}");
    }
}

var d = new Derived("Constructed in main");

----------------Output---------------------------
VritualB constructor start
Derived: Set by initializer
VritualB constructor end
Derived constructor start
Derived: Constructed in main
Derived constructor end

基类的构造函数调用了一个定义在本类中的虚函数，于是派生类实例在运行时调用的就是派生类的版本，即 Derived 的派生版本。

C# 在进入构造函数体之前，已经把该对象的所有成员变量初始化好了，即开发者声明每一个成员变量时写的所有初始化语句都得到了执行。

整个流程如下：

1. msg 首先通过初始化语句赋值为 "Set by initializer"
2. 开始执行构造函数，先执行 base 构造函数
   • base 构造函数调用派生类中的 VFunc 中的方法输出 "Derived: Set by initializer"
3. 执行派生类 Derived 构造函数
   • msg 通过构造函数入参赋值为 "Constructed in main"
   • 再次调用 VFunc

可以看到，构造函数中调用虚方法，可能会导致程序结果不是我们所期望的，除非你清晰理解c#语言规范，否则这样会令程序可读性降低，甚至引起数据混乱。