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

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

我发现的另一件有趣的事情是，通过执行下面这样的操作可以“满足”ReSharper错误，这对我来说是愚蠢的。然而，正如许多前面提到的，在构造函数中调用虚拟财产/方法仍然不是一个好主意。

public class ConfigManager
{
   public virtual int MyPropOne { get; private set; }
   public virtual string MyPropTwo { get; private set; }

   public ConfigManager()
   {
    Setup();
   }

   private void Setup()
   {
    MyPropOne = 1;
    MyPropTwo = "test";
   }
}

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

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

我认为，如果您想让子类能够设置或重写父构造函数将立即使用的属性，则忽略警告可能是合法的：

internal class Parent
{
    public Parent()
    {
        Console.WriteLine("Parent ctor");
        Console.WriteLine(Something);
    }

    protected virtual string Something { get; } = "Parent";
}

internal class Child : Parent
{
    public Child()
    {
        Console.WriteLine("Child ctor");
        Console.WriteLine(Something);
    }

    protected override string Something { get; } = "Child";
}

这里的风险是子类从其构造函数设置属性，在这种情况下，值的更改将在调用基类构造函数之后发生。

我的用例是，我希望子类提供一个特定的值或一个实用程序类（如转换器），而不需要在基础上调用初始化方法。

在实例化子类时，上面的输出是：

Parent ctor
Child
Child ctor
Child

在这个特定的例子中，C++和C#之间有区别。在C++中，对象未初始化，因此在构造函数中调用病毒函数是不安全的。在C#中，当创建类对象时，其所有成员都是零初始化的。可以在构造函数中调用虚拟函数，但如果您将访问仍然为零的成员。如果您不需要访问成员，那么在C#中调用虚拟函数是非常安全的。

因为在构造函数完成执行之前，对象不会完全实例化。虚拟函数引用的任何成员都不能初始化。在C++中，当您处于构造函数中时，这仅指所处构造函数的静态类型，而不是所创建对象的实际动态类型。这意味着虚拟函数调用甚至可能不会到达您期望的位置。