虚拟成员在构造函数中调用

Question

我从ReSharper收到一条关于从我的对象构造函数调用虚拟成员的警告.

为什么不做这件事？

Answer 1

构造用C#编写的对象时,会发生的情况是初始化程序按从最派生类到基类的顺序运行,然后构造函数按顺序从基类运行到最派生类(请参阅Eric Lippert的博客了解详细信息至于为什么这是).

同样在.NET对象中,不会在构造时更改类型,而是从最派生类型开始,方法表用于最派生类型.这意味着虚方法调用始终在最派生类型上运行.

当你将这两个事实结合起来时,你会遇到这样的问题:如果你在构造函数中进行虚方法调用,并且它不是其继承层次结构中派生类型最多的类型,那么它将在没有构造函数的类上调用它.运行,因此可能不适合调用该方法.

当然,如果将类标记为已密封以确保它是继承层次结构中派生类型最多的类型,则可以缓解此问题 - 在这种情况下,调用虚方法是完全安全的.

Answer 2

为了回答您的问题,请考虑以下问题:在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是null.在自己的构造函数之前调用对象的基础构造函数.通过virtual在对象的构造函数中调用,您可以介绍继承对象在完全初始化之前执行代码的可能性.

Answer 3

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之间的规则是如此不同.你的程序员可能不知道会发生什么!

Answer 4

已经描述了警告的原因,但是如何修复警告？你必须密封班级或虚拟成员.

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

Answer 5

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

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

Answer 6

上面有为什么你写得很好的答案不会想这样做.这里有一个反例,其中也许你会想这样做(翻译成从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 { }

Answer 7

是的,在构造函数中调用虚方法通常很糟糕.

此时,对象可能尚未完全构建,并且方法所预期的不变量可能尚未成立.

Answer 8

一个重要的缺失是，解决此问题的正确方法是什么？

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

Answer 9

因为在构造函数完成执行之前,该对象未完全实例化.虚函数引用的任何成员都可能未初始化.在C++中,当您在构造函数中时,this仅引用您所在构造函数的静态类型,而不是正在创建的对象的实际动态类型.这意味着虚函数调用甚至可能不会达到您期望的范围.

Answer 10

您的构造函数(稍后,在您的软件的扩展中)可以从覆盖虚方法的子类的构造函数中调用.现在不是子类的函数实现,但是将调用基类的实现.因此,在这里调用虚函数并没有多大意义.

但是,如果您的设计符合Liskov替换原则,则不会造成任何伤害.可能这就是它被容忍的原因 - 警告,而不是错误.

Answer 11

其他答案尚未解决的这个问题的一个重要方面是,基类在其构造函数中调用虚拟成员是安全的,如果这是派生类期望它做的事情.在这种情况下,派生类的设计者负责确保在构造完成之前运行的任何方法将在这种情况下表现得尽可能合理.例如,在C++/CLI中,构造函数包含在代码中,Dispose如果构造失败,它将调用部分构造的对象.Dispose在这种情况下调用通常是必要的,以防止资源泄漏,但Dispose必须准备方法,以确保它们运行的​​对象可能没有完全构建.