我只需要向基类添加一个Initialize（）方法，然后从派生构造函数调用它。在执行所有构造函数之后，该方法将调用任何虚拟/抽象方法/财产：）

对于你为什么不想这样做，上面有很好的答案。这里有一个反例，也许你想这样做（由Sandi Metz翻译成C#，来自Ruby中的实用面向对象设计，第126页）。

注意，GetDependency（）没有触及任何实例变量。如果静态方法可以是虚拟的，那么它将是静态的。

（公平地说，可能有更聪明的方法通过依赖注入容器或对象初始化器来实现这一点…）

public class MyClass
{
    private IDependency _myDependency;

    public MyClass(IDependency someValue = null)
    {
        _myDependency = someValue ?? GetDependency();
    }

    // If this were static, it could not be overridden
    // as static methods cannot be virtual in C#.
    protected virtual IDependency GetDependency() 
    {
        return new SomeDependency();
    }
}

public class MySubClass : MyClass
{
    protected override IDependency GetDependency()
    {
        return new SomeOtherDependency();
    }
}

public interface IDependency  { }
public class SomeDependency : IDependency { }
public class SomeOtherDependency : IDependency { }

只是为了补充我的想法。如果在定义私有字段时总是初始化它，那么应该避免这个问题。至少以下代码就像一个符咒：

class Parent
{
    public Parent()
    {
        DoSomething();
    }
    protected virtual void DoSomething()
    {
    }
}

class Child : Parent
{
    private string foo = "HELLO";
    public Child() { /*Originally foo initialized here. Removed.*/ }
    protected override void DoSomething()
    {
        Console.WriteLine(foo.ToLower());
    }
}

您的构造函数（稍后，在软件的扩展中）可以从重写虚拟方法的子类的构造函数调用。现在不是子类的函数实现，而是基类的实现将被调用。所以在这里调用虚拟函数是没有意义的。

然而，如果您的设计满足Liskov替换原则，则不会造成任何伤害。也许这就是为什么它被容忍的原因——一个警告，而不是错误。

当用C#编写的对象被构造时，会发生的情况是初始化器按照从最派生类到基类的顺序运行，然后构造函数按照从基类到最派生类的顺序运行（有关为什么这样做的详细信息，请参阅Eric Lippert的博客）。

此外，在.NET对象中，对象在构造时不会改变类型，而是从最派生的类型开始，方法表是最派生的。这意味着虚拟方法调用总是在最派生的类型上运行。

当你结合这两个事实时，你会遇到这样的问题：如果你在构造函数中调用了一个虚拟方法，并且它不是继承层次结构中最派生的类型，那么它将在一个尚未运行构造函数的类上被调用，因此可能不处于调用该方法的合适状态。

当然，如果您将类标记为密封的，以确保它是继承层次结构中最派生的类型，那么这个问题就会得到缓解——在这种情况下，调用虚拟方法是完全安全的。

重要的一点是，解决这个问题的正确方法是什么？

正如Greg所解释的，这里的根本问题是基类构造函数会在构造派生类之前调用虚拟成员。

以下代码摘自MSDN的构造函数设计指南，演示了这个问题。

public class BadBaseClass
{
    protected string state;

    public BadBaseClass()
    {
        this.state = "BadBaseClass";
        this.DisplayState();
    }

    public virtual void DisplayState()
    {
    }
}

public class DerivedFromBad : BadBaseClass
{
    public DerivedFromBad()
    {
        this.state = "DerivedFromBad";
    }

    public override void DisplayState()
    {   
        Console.WriteLine(this.state);
    }
}

创建DerivedFromBad的新实例时，基类构造函数调用DisplayState并显示BadBaseClass，因为派生构造函数尚未更新该字段。

public class Tester
{
    public static void Main()
    {
        var bad = new DerivedFromBad();
    }
}

一个改进的实现从基类构造函数中删除了虚拟方法，并使用了Initialize方法。创建DerivedFromBetter的新实例将显示预期的“DerivedFromBetter”

public class BetterBaseClass
{
    protected string state;

    public BetterBaseClass()
    {
        this.state = "BetterBaseClass";
        this.Initialize();
    }

    public void Initialize()
    {
        this.DisplayState();
    }

    public virtual void DisplayState()
    {
    }
}

public class DerivedFromBetter : BetterBaseClass
{
    public DerivedFromBetter()
    {
        this.state = "DerivedFromBetter";
    }

    public override void DisplayState()
    {
        Console.WriteLine(this.state);
    }
}