为什么这个多态 C# 代码会打印它的功能？

Question

我最近收到了以下代码，作为一个谜题，以帮助理解 OOP - C# 中的多态性和继承。

// No compiling!
public class A
{
     public virtual string GetName()
     {
          return "A";
     }
 }

 public class B:A
 {
     public override string GetName()
     {
         return "B";
     }
 }

 public class C:B
 {
     public new string GetName()
     {
         return "C";
     }
 }

 void Main()
 {
     A instance = new C();
     Console.WriteLine(instance.GetName());
 }
 // No compiling!

现在，在与提出谜题的其他开发人员进行了长时间的交谈后，我知道输出是什么，但我不会为你剧透。我真正遇到的唯一问题是我们如何获得该输出，代码如何执行，继承什么等等。

我认为C 会被返回，因为这似乎是定义的类。然后我想知道B是否会被返回，因为C继承了B——但B也继承了A（这让我感到困惑！）。

---

问题：

谁能解释多态性和继承如何在检索输出中发挥作用，最终显示在屏幕上？

Answer 1

好的，帖子有点老了，但这是一个很好的问题和一个很好的答案，所以我只是想补充一下我的想法。

考虑下面的例子，除了主函数之外，它和之前一样：

// No compiling!
public class A
{
    public virtual string GetName()
    {
        return "A";
    }
}

public class B:A
{
    public override string GetName()
    {
        return "B";
    }
}

public class C:B
{
    public new string GetName()
    {
        return "C";
    }
}

void Main()
{
    Console.Write ( "Type a or c: " );
    string input = Console.ReadLine();

    A instance = null;
    if      ( input == "a" )   instance = new A();
    else if ( input == "c" )   instance = new C();

   Console.WriteLine( instance.GetName() );
}
// No compiling!

现在很明显，函数调用不能在编译时绑定到特定函数。但是，必须编译某些内容，并且该信息只能取决于引用的类型。因此，除了 C 类型之外的任何引用都无法执行 C 类的 GetName 函数。

附：也许我应该使用术语方法而不是函数，但正如莎士比亚所说：任何其他名称的函数仍然是函数:)

Answer 2

思考这个问题的正确方法是想象每个类都要求它的对象有一定数量的“槽”；这些插槽充满了方法。问题“实际上调用了什么方法？”需要你弄清楚两件事：

1. 每个槽的内容是什么？
2. 调用哪个槽？

让我们从考虑插槽开始。有两个插槽。 A 的所有实例都需要有一个我们称之为 GetNameSlotA 的槽。 C 的所有实例都必须有一个我们称之为 GetNameSlotC 的槽。这就是 C 中声明中“新”的含义——它的意思是“我想要一个新插槽”。相比于 B 中声明的“override”，意思是“我不想要新的 slot，我要重用 GetNameSlotA”。

当然，C继承自A，所以C也必须有一个槽GetNameSlotA。因此，C 的实例有两个插槽——GetNameSlotA 和 GetNameSlotC。不是 C 的 A 或 B 的实例有一个插槽，GetNameSlotA。

现在，当您创建一个新的 C 时，这两个插槽中的内容是什么？共有三种方法，我们将它们称为 GetNameA、GetNameB 和 GetNameC。

A 的声明说“将 GetNameA 放入 GetNameSlotA”。 A 是 C 的超类，因此 A 的规则适用于 C。

B 的声明说“将 GetNameB 放入 GetNameSlotA”。 B 是 C 的超类，因此 B 的规则适用于 C 的实例。现在我们在 A 和 B 之间发生冲突。B 是派生更多的类型，所以它获胜 -- B 的规则覆盖 A 的规则.因此声明中的“覆盖”一词。

C 的声明说“将 GetNameC 放入 GetNameSlotC”。

因此，您的新 C 将有两个插槽。 GetNameSlotA 将包含 GetNameB，GetNameSlotC 将包含 GetNameC。

我们现在已经确定了哪些方法在哪些槽中，所以我们已经回答了我们的第一个问题。

现在我们要回答第二个问题。叫什么槽？

把它想象成你是编译器。你有一个变量。您所知道的只是它属于 A 类型。您被要求解析对该变量的方法调用。您查看 A 上可用的插槽，您可以找到匹配的唯一插槽是 GetNameSlotA。你不知道GetNameSlotC，因为你只有一个A类型的变量；为什么要寻找只适用于 C 的插槽？

因此，这是对 GetNameSlotA 中的任何内容的调用。我们已经确定在运行时，GetNameB 将位于该槽中。因此，这是对 GetNameB 的调用。

这里的关键点是在 C# 重载解析中选择一个槽并生成对该槽中的任何内容的调用。

Answer 3

很简单，您只需要记住继承树即可。

在您的代码中，您持有对“A”类型类的引用，该类由“C”类型的实例实例化。现在，为了解析虚拟 'GetName()' 方法的确切方法地址，编译器向上继承层次结构并查找最近的 override（请注意，只有 'virtual' 是覆盖， “新”是完全不同的东西......）。

简而言之，就是这样。 'C' 类型的 new 关键字只有在你在'C' 类型的实例上调用它时才会起作用，然后编译器会完全否定所有可能的继承关系。严格来说，这与多态性完全没有关系——你可以从这样一个事实中看出，无论你用 'new' 关键字屏蔽虚拟方法还是非虚拟方法都没有任何区别......

'C' 类中的'New' 的确切含义是：如果您在此（确切）类型的实例上调用 'GetName()'，则忘记所有内容并使用 THIS 方法。 'Virtual' 相反的意思是：无论调用实例的确切类型是什么，沿着继承树向上直到找到具有此名称的方法。

Answer 4

其实我觉得应该显示C，因为new操作符只是隐藏了all同名的祖先方法。因此，隐藏了 A 和 B 的方法后，只有 C 保持可见。

http://msdn.microsoft.com/en-us/library/51y09td4%28VS.71%29.aspx#vclrfnew_newmodifier

Answer 5

它应该返回“B”，因为B.GetName() 保存在A.GetName() 函数的小虚拟表框中。 C.GetName() 是编译时“覆盖”，它不会覆盖虚拟表，因此您无法通过指向 A 的指针检索它。