1405

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

为什么这是不应该做的事情？

4

18 回答 18

1222

当一个用 C# 编写的对象被构​​造时，会发生初始化程序从最派生类到基类的顺序运行，然后构造函数从基类到最派生类的顺序运行（详见 Eric Lippert 的博客）至于为什么会这样）。

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

当你结合这两个事实时，你会遇到一个问题，如果你在构造函数中调用虚方法，并且它不是继承层次结构中最派生的类型，它将在构造函数尚未被调用的类上调用。运行，因此可能不处于调用该方法的合适状态。

当然，如果您将类标记为密封以确保它是继承层次结构中最派生的类型，这个问题当然会得到缓解——在这种情况下，调用虚方法是完全安全的。

于 2008-09-23T07:21:13.747 回答
727

为了回答你的问题，考虑这个问题：当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!?!
    }
}

答案是实际上 aNullReferenceException会被抛出，因为foo它是 null。对象的基本构造函数在其自己的构造函数之前被调用。通过virtual在对象的构造函数中进行调用，您将引入继承对象在完全初始化之前执行代码的可能性。

于 2008-09-23T07:17:47.547 回答
166

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

于 2008-09-23T07:36:08.687 回答
90

警告的原因已经描述了，但是您将如何解决警告？您必须密封类或虚拟成员。

  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();
    }
  }
于 2008-09-23T13:20:22.323 回答
21

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

请注意，这只是提醒您注意并确保一切正常的警告。这种情况有实际的用例，您只需记录虚拟成员的行为，它不能使用在调用它的构造函数所在的派生类中声明的任何实例字段。

于 2008-09-23T07:21:04.107 回答
13

上面有写得很好的答案，说明您为什么不想这样做。这是一个反例，您可能希望这样做（从Sandi Metz 的Practical Object-Oriented Design in Ruby翻译成 C# ，第 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 { }
于 2012-12-28T01:19:13.467 回答
8

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

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

于 2008-09-23T07:15:32.027 回答
6

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

正如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);
    }
}
于 2015-08-14T19:50:17.520 回答
5

因为在构造函数完成执行之前，对象还没有完全实例化。虚函数引用的任何成员都可能不会被初始化。在 C++ 中，当您在构造函数中时，this仅指您所在构造函数的静态类型，而不是正在创建的对象的实际动态类型。这意味着虚函数调用甚至可能不会去你期望的地方。

于 2008-09-23T07:14:10.877 回答
5

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

但是，如果您的设计满足 Liskov 替换原则，则不会造成任何损害。可能这就是它被容忍的原因 - 警告，而不是错误。

于 2008-09-23T07:25:01.973 回答
5

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

于 2012-10-25T20:33:34.563 回答
3

该警告提醒您，虚拟成员可能会在派生类上被覆盖。在这种情况下，父类对虚拟成员所做的任何事情都将通过覆盖子类来撤消或更改。为了清楚起见，看一下小例子

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

这里的子类覆盖了父属性。如果此属性未标记为虚拟，编译器会警告该属性隐藏了父类上的属性，并建议您添加“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"
    }
}
于 2016-08-28T18:25:48.513 回答
3

谨防盲目听从 Resharper 的建议，让课程被封印！如果它是 EF Code First 中的模型，它将删除 virtual 关键字，这将禁用延迟加载它的关系。

    public **virtual** User User{ get; set; }
于 2017-10-05T19:15:39.147 回答
1

在这种特定情况下，C++ 和 C# 之间存在差异。在 C++ 中，对象未初始化，因此在构造函数中调用虚拟函数是不安全的。在 C# 中，当创建类对象时，其所有成员都初始化为零。可以在构造函数中调用虚函数，但如果您可能访问仍然为零的成员。如果您不需要访问成员，那么在 C# 中调用虚函数是非常安全的。

于 2008-09-23T07:18:32.643 回答
1

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

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());
    }
}
于 2015-10-14T16:23:58.093 回答
1

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

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
于 2019-12-11T11:55:40.360 回答
-2

我只需将 Initialize() 方法添加到基类，然后从派生构造函数中调用它。该方法将在所有构造函数执行后调用任何虚拟/抽象方法/属性:)

于 2017-12-13T21:14:46.317 回答
-3

我发现的另一件有趣的事情是，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";
   }
}
于 2014-05-22T16:50:58.327 回答