C#的规则与Java和C++的规则非常不同。

当您在C#中的某个对象的构造函数中时，该对象以完全初始化（只是不是“构造”）的形式存在，作为其完全派生类型。

namespace Demo
{
    class A 
    {
      public A()
      {
        System.Console.WriteLine("This is a {0},", this.GetType());
      }
    }

    class B : A
    {      
    }

    // . . .

    B b = new B(); // Output: "This is a Demo.B"
}

这意味着，如果从a的构造函数调用虚拟函数，它将解析为B中的任何重写（如果提供了重写）。

即使你有意这样设置A和B，充分理解系统的行为，你也可能会在以后受到冲击。假设您在B的构造函数中调用了虚拟函数，“知道”它们将由B或A酌情处理。然后时间过去了，其他人决定他们需要定义C，并重写其中的一些虚拟函数。突然间，B的构造函数最终调用了C中的代码，这可能会导致非常令人惊讶的行为。

无论如何，避免构造函数中的虚函数可能是一个好主意，因为C#、C++和Java之间的规则是如此不同。你的程序员可能不知道该怎么做！

在C#中，基类构造函数在派生类构造函数之前运行，因此派生类可能在可能重写的虚拟成员中使用的任何实例字段都尚未初始化。

请注意，这只是一个警告，让你注意并确保一切正常。这个场景有实际的用例，您只需要记录虚拟成员的行为，它不能使用下面的派生类中声明的任何实例字段，构造函数调用它。

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

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());
    }
}

警告的原因已经描述过了，但您将如何修复警告？您必须密封类或虚拟成员。

  class B
  {
    protected virtual void Foo() { }
  }

  class A : B
  {
    public A()
    {
      Foo(); // warning here
    }
  }

您可以密封A类：

  sealed class A : B
  {
    public A()
    {
      Foo(); // no warning
    }
  }

或者您可以密封方法Foo：

  class A : B
  {
    public A()
    {
      Foo(); // no warning
    }

    protected sealed override void Foo()
    {
      base.Foo();
    }
  }

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

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

对于你为什么不想这样做，上面有很好的答案。这里有一个反例，也许你想这样做（由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 { }