我发现的另一件有趣的事情是，通过执行下面这样的操作可以“满足”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";
   }
}

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

正如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);
    }
}

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

是的，在构造函数中调用虚拟方法通常是不好的。

此时，对象可能还没有完全构造，方法所期望的不变量可能还不成立。

这个问题的一个重要方面（其他答案尚未解决）是，如果派生类希望基类从其构造函数中调用虚拟成员，则基类是安全的。在这种情况下，派生类的设计者负责确保在构造完成之前运行的任何方法都将在这种情况下尽可能合理地运行。例如，在C++/CLI中，构造函数被包装在代码中，如果构造失败，这些代码将对部分构造的对象调用Dispose。在这种情况下，调用Dispose通常是防止资源泄漏所必需的，但Dispose方法必须做好准备，以防运行它们的对象可能尚未完全构造。

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

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