为什么这有效？方法重载 +方法重写 +多态性

Question

在以下代码中：

public abstract class MyClass
{
public abstract bool MyMethod(
        Database database,
        AssetDetails asset,
        ref string errorMessage);
}

public sealed class MySubClass : MyClass
{
    public override bool MyMethod(
        Database database,
        AssetDetails asset,
        ref string errorMessage)
    {
        return MyMethod(database, asset, ref errorMessage);
    }

    public bool MyMethod(
        Database database,
        AssetBase asset,
        ref string errorMessage)
    {
    // work is done here
}
}

其中 AssetDetails 是 AssetBase 的子类。

为什么第一个 MyMethod 在传递 AssetDetails 时在运行时调用第二个 MyMethod，而不是陷入无限递归循环？

Answer 1

C# 将解析您对其他实现的调用，因为对对象上的方法的调用（其中该对象的类有其自己的实现）将优先于重写或继承的方法。

这可能会导致微妙且难以发现的问题，就像您在此处所示的那样。

例如，尝试这段代码（首先读取它，然后编译并执行它），看看它是否达到了您期望的效果。

using System;

namespace ConsoleApplication9
{
    public class Base
    {
        public virtual void Test(String s)
        {
            Console.Out.WriteLine("Base.Test(String=" + s + ")");
        }
    }

    public class Descendant : Base
    {
        public override void Test(String s)
        {
            Console.Out.WriteLine("Descendant.Test(String=" + s + ")");
        }

        public void Test(Object s)
        {
            Console.Out.WriteLine("Descendant.Test(Object=" + s + ")");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Descendant d = new Descendant();
            d.Test("Test");
            Console.In.ReadLine();
        }
    }
}

请注意，如果您将变量的类型声明为 Base 类型而不是 Descendant 类型，则调用将转到另一个方法，请尝试更改此行：

Descendant d = new Descendant();

对此，并重新运行：

Base d = new Descendant();

那么，您实际上如何调用Descendant.Test(String)呢？

我的第一次尝试如下所示：

public void Test(Object s)
{
    Console.Out.WriteLine("Descendant.Test(Object=" + s + ")");
    Test((String)s);
}

这对我没有任何好处，而是一次又一次地调用 Test(Object) 以防止最终的堆栈溢出。

但是，以下有效。因为，当我们将 d 变量声明为 Base 类型时，我们最终会调用正确的虚拟方法，因此我们也可以采用这种技巧：

public void Test(Object s)
{
    Console.Out.WriteLine("Descendant.Test(Object=" + s + ")");
    Base b = this;
    b.Test((String)s);
}

这将打印out：

Descendant.Test(Object=Test)
Descendant.Test(String=Test)

您也可以从外部执行此操作：

Descendant d = new Descendant();
d.Test("Test");
Base b = d;
b.Test("Test");
Console.In.ReadLine();

将打印出相同的内容。

但首先您需要意识到问题，这完全是另一回事。

Answer 2

请参阅 C# 语言规范中有关成员查找 和重载解析。由于成员查找规则，派生类的重写方法不是候选方法，并且根据重载解析规则，基类方法不是最佳匹配。

第 7.3 节

首先，构造 T 中声明的名为 N 的所有可访问（第 3.5 节）成员和 T 的基本类型（第 7.3.1 节）的集合。包含 override 修饰符的声明被排除在该集合之外。如果不存在名为 N 的成员且可访问，则查找不会产生匹配项，并且不会评估以下步骤。

第 7.4.2 节：

每个上下文都以自己独特的方式定义候选函数成员集和参数列表，如上面列出的部分中详细描述的。例如，方法调用的候选集不包括标记为 override 的方法（第 7.3 节），并且如果派生类中的任何方法适用，则基类中的方法不是候选（第 7.5 节） .5.1）。 （强调我的）

Answer 3

正如其他人正确指出的那样，当在类中的两个适用候选方法之间进行选择时，编译器总是选择最初声明的与该类“更接近”的方法。包含检查基类层次结构时的调用站点。

这似乎违反直觉。当然，如果在基类上声明了精确匹配，那么这比在派生类上声明的不精确匹配更好，是吗？

不会。始终选择派生较多的方法而不是派生较少的方法有两个原因。

首先是派生类的作者比基类的作者拥有更多的信息。派生类的作者了解基类和派生类的所有信息，毕竟派生类是调用者实际使用的类。当在调用由无所不知的人编写的方法与仅了解调用者所使用的类型的人编写的方法之间进行选择时，显然优先调用由派生类设计者编写的方法是有意义的。

其次，做出这样的选择会导致某种形式的脆弱基类失败。我们希望保护您免受这种故障的影响，因此编写了重载解析规则，以便尽可能避免这种情况。

有关此规则如何保护您免受脆弱基类故障影响的详细说明，请参阅 我关于该主题的文章。

有关语言处理脆弱基类情况的其他方式的文章，请点击此处 。

Answer 4

因为这就是语言的定义方式。对于虚拟成员，当基类和派生类中都存在方法时，在运行时调用的实现基于具体类型< /strong> 调用方法的对象的类型，而不是保存对象引用的变量的声明类型。您的第一个 MyMethod 位于抽象类中。因此它永远不能从MyClass类型的对象调用——因为这样的对象永远不存在。您可以实例化的只是派生类MySubClass。具体类型是MySubClass，因此无论调用它的代码是否在基类中，都会调用该实现。

对于非虚拟成员/方法，情况恰恰相反。