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

下面的父类试图将值设置为其构造函数上的虚拟成员。这将触发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"
    }
} 

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

小心盲目地听从Resharper的建议，让课堂变得封闭！如果它是EF Code First中的模型，它将删除虚拟关键字，这将禁用其关系的延迟加载。

    public **virtual** User User{ get; set; }

对于你为什么不想这样做，上面有很好的答案。这里有一个反例，也许你想这样做（由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 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替换原则，则不会造成任何伤害。也许这就是为什么它被容忍的原因——一个警告，而不是错误。