在 C# 的基类构造函数中覆盖和调用相同的方法

Question

我的烦恼是：在下面显示的代码中，它应该显示A，然后是B。但它显示B 然后B。为什么会这样？

我的感觉是，A 的构造函数在创建B 的对象时首先被执行。在那种情况下，B 中的方法不会被击中吧？所以它应该是A.Display()，结果应该是A。另外，a.Display() 应该返回 B，因为我们有覆盖。

所以我希望A 然后是B。因为它不是重载而是压倒一切。我知道这些东西的定义，我希望了解这种行为的原因以及它在内部是如何工作的，因为我不相信BB 但AB。

---

代码

class A
{
    public A()
    {
        this.Display();
    }
    public virtual void Display()
    {
        Console.WriteLine("A");
    }
}

class B :A
{
    public override void Display()
    {
        Console.WriteLine("B");
    }
}

class C
{
    static void Main()
    {
        A a = new B();
        a.Display();
        Console.WriteLine();
        Console.ReadLine();
    }
}

---

输出

1) 在派生类中重写 Display 方法会产生以下结果：

A a = new A(); // ---> AA
B a = new B(); // ---> BB // I expect AB.
A a = new B(); // ---> BB // I expect AB.

2) 在派生类的 Display 方法中使用 NEW 关键字会产生以下结果：

B a = new B(); // ---> AB // I Expect AA here.
A a = new B(); // ---> AA
A a = new A(); // ---> AA

3) 更有趣的发现是：

当我在派生构造函数中使用base.Display() 并覆盖派生类中的基方法时，它给了我BAB

至少在这方面我看不到任何逻辑。因为，它应该给BBB

Answer 1

我的感觉是，A的构造函数在创建B的对象时首先被执行。

正确。

那样的话，B中的方法不会被命中吧？

这是不正确的。

在 C++ 中的类似代码中，您是正确的。在 C++ 中，有一条规则是在构建对象时构建虚函数调度表。也就是说，当进入“A”构造函数时，vtable 被“A”中的方法填充。当控制权转到“B”ctor 时，vtable 会被 B 的方法填充。

在 C# 中情况并非如此。在 C# 中，vtable 在对象从内存分配器中出来的那一刻被填充，在任何一个 ctor 执行之前，之后它就不会改变。方法的 vtable 槽始终包含派生最多的方法。

因此，像您在这里所做的那样在 ctor 中调用虚方法是一个非常糟糕的主意。可以在其 ctor 尚未运行的类上调用虚拟方法！因此它可能依赖于尚未初始化的状态。

请注意，字段初始值设定项在所有 ctor 主体之前运行，因此幸运的是，对更派生类的覆盖将始终在覆盖类的字段初始值设定项之后运行。

这个故事的寓意是：不要那样做。永远不要在 ctor 中调用虚拟方法。在 C++ 中，您可能会获得与预期不同的方法，而在 C# 中，您可能会获得使用未初始化状态的方法。避免，避免，避免。

为什么我们不应该在 ctor 中调用虚方法？是因为我们总是在 vtable 中只得到（最新派生的）结果吗？

是的。我举个例子来说明：

class Bravo
{
    public virtual void M() 
    {
        Console.WriteLine("Bravo!");
    }
    public Bravo()
    {
        M(); // Dangerous!
    }
}
class Delta : Bravo:
{
    DateTime creation;
    public override void M() 
    {
        Console.WriteLine(creation);
    }
    public Delta() 
    {
        creation = DateTime.Now;
    }
}

好的，所以这个程序的预期行为是，当在任何Delta 上调用M 时，它将打印出创建实例的时间。但是new Delta()上的事件顺序是：

• Bravoctor 运行
• Bravo ctor 致电 this.M
• M 是虚拟的，this 是运行时类型 Delta 所以 Delta.M 运行
• Delta.M 打印出 uninitialized 字段，该字段设置为默认时间，而不是当前时间。
• M返回
• Bravoctor 返回
• Deltactor 设置字段

现在你明白我所说的覆盖方法可能依赖于尚未初始化的状态的意思了吗？在M 的任何其他用法中，这很好，因为Delta ctor 已经完成。但是这里 M 在 Delta ctor 开始之前就被调用了！

Answer 2

您创建对象B 的实例。它使用在类A 上定义的构造函数的代码，因为您没有在B 中覆盖它。但是实例仍然是B，所以构造函数中调用的其他方法是B中定义的方法，而不是A。因此，您会看到在类 B 中定义的 Display() 的结果。

根据问题的更新进行更新

我将尝试解释您得到的“奇怪”结果。

当覆盖时：

B a = 新 B(); // ---> BB // 我期待 AB。

A a = 新 B(); // ---> BB // 我期待 AB。

这在上面已经介绍过了。当您覆盖子类的方法时，如果您使用的是子类的实例，则使用此方法。这是一个基本规则，使用的方法由变量实例的类决定，而不是由用于声明变量的类决定。

当为方法使用new修饰符时（隐藏继承的方法）

B a = 新 B(); // ---> AB // 我在这里期待 AA。

现在这里有两种不同的行为：

• 当使用构造函数时，它使用类A中的构造函数。由于继承的方法隐藏在子类中，构造函数使用类 A 中的 Display() 方法，因此您会看到打印的 A。

• 以后直接调用Display()时，变量的实例是B。出于这个原因，它使用在类B 上定义的方法来打印B。

Answer 3

---

初始声明

我将从基本代码开始，我已将其调整为在LINQPad 中运行（我也将其更改为Write 而不是WriteLine，因为无论如何我都不会在解释中保留新行)。

class A
{
    public A()
    {
        this.Display();
    }

    public virtual void Display()
    {
        Console.Write("A"); //changed to Write
    }
}

class B :A
{
    public override void Display()
    {
        Console.Write("B"); //changed to Write
    }
}

static void Main()
{
    A a = new B();
    a.Display();
}

输出是：

BB

---

在你最初的问题中，你说你期待：

AB

这里发生的事情（如Szymon attempted to explain）是您正在创建一个B 类型的对象和B 类覆盖 类Display 的方法A。因此，每当您对该对象调用 Display 时，它将是派生类 (B) 的方法，即使来自 A 的构造函数。

---

我会复习你提到的所有案例。我想鼓励您仔细阅读。另外，请保持开放的态度，因为这与某些其他语言中发生的情况不符。

---

1) 在派生类中重写 Display 方法

这是您覆盖方法的情况，即：

public override void Display()
{
    Console.Write("B"); //changed to Write
}

当您重写时，对于所有实际用途，将使用的方法是派生类的方法。将覆盖视为替换。

案例 1：

A a = new A(); // ---> AA

我们没问题。

案例 2：

B a = new B(); // ---> BB // I expect AB.

如上所述，在对象上调用Display 将始终是派生类上的方法。因此，对Display 的两次调用都会产生B。

案例 3：

A a = new B(); // ---> BB // I expect AB.

这是相同混淆的变体。该对象显然属于B 类型，即使您将它放在A 类型的变量中。请记住，在 C# 中，类型是对象的属性而不是变量的属性。所以，结果和上面一样。

---

注意：您仍然可以使用base.Display() 访问被替换的方法。

---

2) 在派生类的Display方法中使用NEW关键字

这是您隐藏方法的情况，即：

public new void Display()
{
    Console.Write("B"); //changed to Write
}

当你隐藏方法时，意味着原来的方法仍然可用。您可以将其视为一种不同的方法（恰好具有相同的名称和签名）。也就是说：派生类不会替换覆盖该方法。

因此，当您对对象进行（虚拟）调用时，在编译时决定将使用基类的方法......派生类的方法没有被考虑在内（实际上，它不是虚拟呼叫）。

这样想：如果您使用基类的变量调用方法...代码不知道存在隐藏该方法的派生类，并且该特定调用可以使用以下之一执行那些对象。相反，它将使用基类的方法，无论如何。

案例 1：

B a = new B(); // ---> AB // I Expect AA here.

你看，在编译时，构造函数中的调用被设置为使用基类的方法。那个给A。但由于变量的类型为B，编译器知道该方法在第二次调用时被隐藏了。

案例 2：

A a = new B(); // ---> AA

在这里，无论是在构造函数中还是在第二次调用中，它都不会使用新方法。它不知道它。

案例 3：

A a = new A(); // ---> AA

我认为这一点很清楚。

---

3) 使用 base.Display()

这是您执行此操作的代码变体：

public new void Display()
{
    base.Display();
    Console.Write("B"); //changed to Write
}

base.Display() 将成为基类 (A) 中的方法，无论如何。

---

进一步阅读

你说你想了解它是如何在内部工作的。

您可以通过阅读Microsoft's C# Spec on Virtual Methods 来深入了解

然后阅读 Eric Lippert 在 C# 中实现虚拟方法模式（part 1、part 2 和 part 3）

您可能也有兴趣：

• Anders on virtual calls from constructors。
• Eric Lippert 的《为什么初始化程序作为构造函数以相反的顺序运行？ （part 1 和 part 2）

---

来自网络的虚拟方法的其他解释：

• What's the difference between override and new? (msdn.com)
• C# Virtual (dotnetpearls.com)
• Understanding virtual, override and new keyword in C# (dotnet-tricks.com)
• Understanding C#: Using virtual and override (oreilly.com)

Answer 4

将类命名为 a 而将其实例化为类 B，您可能会感到困惑。如果你想调用虚拟方法，你可以使用 base 关键字。以下代码写成A B

class A
{
    public A()
    {
        //this.Display();
    }
    public virtual void Display()
    {
        Console.WriteLine("A");
    }
}

class B : A
{
    public override void Display()
    {
        base.Display();
        Console.WriteLine("B");
    }
}

class C
{
    static void Main(string[] args)
    {
        A a = new B();
        a.Display();
        Console.WriteLine();
        Console.ReadLine();
    }
}

另请注意，您可以通过在开头设置断点然后逐行遍历代码执行 (F11) 来了解代码显示 B B 的原因。

Answer 5

我的理解是，在虚拟方法的情况下，父对象和子对象共享相同的方法槽。

如果是这样，那么我认为当调用对象虚拟方法时，编译器会以某种方式使用适当的方法地址更新方法槽，以便在 c# 中 jitted 并执行确切的方法。