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

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

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

该警告提醒您虚拟成员很可能在派生类上被重写。在这种情况下，父类对虚拟成员所做的任何操作都将通过重写子类来撤消或更改。看一下这个小例子

下面的父类试图将值设置为其构造函数上的虚拟成员。这将触发Re sharper警告，请参见代码：

public class Parent
{
    public virtual object Obj{get;set;}
    public Parent()
    {
        // Re-sharper warning: this is open to change from 
        // inheriting class overriding virtual member
        this.Obj = new Object();
    }
}

此处的子类重写父属性。如果此属性未标记为virtual，编译器将警告该属性隐藏父类上的属性，如果有意，建议您添加“new”关键字。

public class Child: Parent
{
    public Child():base()
    {
        this.Obj = "Something";
    }
    public override object Obj{get;set;}
}

最后是对使用的影响，下面示例的输出放弃了父类构造函数设置的初始值。这就是Re sharper试图警告您的，在父类构造函数上设置的值将被子类构造函数覆盖，子类构造函数在父类构造器之后立即调用。

public class Program
{
    public static void Main()
    {
        var child = new Child();
        // anything that is done on parent virtual member is destroyed
        Console.WriteLine(child.Obj);
        // Output: "Something"
    }
} 

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

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

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

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

为了回答您的问题，请考虑以下问题：当Child对象被实例化时，下面的代码将打印出什么？

class Parent
{
    public Parent()
    {
        DoSomething();
    }

    protected virtual void DoSomething() 
    {
    }
}

class Child : Parent
{
    private string foo;

    public Child() 
    { 
        foo = "HELLO"; 
    }

    protected override void DoSomething()
    {
        Console.WriteLine(foo.ToLower()); //NullReferenceException!?!
    }
}

答案是，实际上会引发NullReferenceException，因为foo为空。对象的基构造函数在其自身构造函数之前调用。通过在对象的构造函数中进行虚拟调用，您引入了继承对象在完全初始化之前执行代码的可能性。