C# 中方法隐藏如何工作？ （第二部分）

Question

以下程序会打印

A:C(A,B)
B:C(A,B)

（应该如此）

public interface I
{
    string A();
}

public class C : I
{
    public string A()
    {
        return "A";
    }

    public string B()
    {
        return "B";
    }
}

public class A
{
    public virtual void Print(C c)
    {
        Console.WriteLine("A:C(" + c.A() + "," + c.B() + ")");
    }
}

public class B : A
{
    public new void Print(C c)
    {
        Console.WriteLine("B:C(" + c.A() + "," + c.B() + ")");
    }

    public void Print(I i)
    {
        Console.WriteLine("B:I(" + i.A() + ")");
    }
}

class Program
{
    public static void Main(string[] args)
    {
        A a = new A();
        B b = new B();
        C c = new C();
        a.Print(c);
        b.Print(c);
    }
}

但是，如果我将 B 类中的关键字“new”更改为“override”，则

    public override void Print(C c)

：突然程序开始打印：

A:C(A,B)
B:I(A)

为什么？

Answer 1

这与重载方法的解析方式有关。

实际上（稍微简化），在本例中，编译器首先查看表达式 (B) 的声明类型，并查找首先在该类型中声明的候选方法。 如果有任何合适的方法（即所有参数都可以转换为方法的参数类型），那么它不会查看任何父类型。 这意味着初始声明位于父类型中的重写方法不会查看派生类型中是否存在任何“新声明”的适当方法。

这是一个稍微简单一点的示例：

using System;

class Base
{
    public virtual void Foo(int x)
    {
        Console.WriteLine("Base.Foo(int)");
    }
}

class Derived : Base
{
    public override void Foo(int x)
    {
        Console.WriteLine("Derived.Foo(int)");
    }

    public void Foo(double d)
    {
        Console.WriteLine("Derived.Foo(double)");
    }
}

class Test
{
    static void Main()
    {
        Derived d = new Derived();
        d.Foo(10);
    }
}

这会打印 Derived.Foo(double) - 即使编译器知道存在一个参数为 int 类型的匹配方法，并且参数为类型 int，并且从 int 到 int 的转换比从 int 到 的转换“更好” >double，事实上，只有 Foo(double) 方法最初在 Derived 中声明，这意味着编译器会忽略 Foo(int).

在我看来，这是非常令人惊讶的。 我可以理解为什么如果 Derived 没有重写 Foo 会出现这种情况 - 否则在基类中引入一个新的、更具体的方法可能会意外地改变行为 -但显然这里Derived知道关于Base.Foo(int)，因为它覆盖了它。 这是我认为 C# 设计者做出错误决定的（相对较少的）点之一。

Answer 2

好的，

    public new void Print(C c)
    {
        Console.WriteLine("B:C(" + c.A() + "," + c.B() + ")");
    }

    public void Print(I i)
    {
        Console.WriteLine("B:I(" + i.A() + ")");
    }

这声明了一个新的打印方法。 现在因为 B 继承自 A，所以您只需调用新方法两次。 当您覆盖该方法时，这会在您调用 A 时更改方法签名，但当您调用 B 签名时，它就会有自己的方法签名。

我不确定我是否解释清楚但很好的问题。

使用 new：

A 和 B 获得相同的打印方法实现。

使用覆盖：

A 与 B 具有不同的方法签名，因为您没有仅在 A 中更改 B 中的方法签名。

使用 new 它基本上会忽略这一点：

    public void Print(I i)
    {
        Console.WriteLine("B:I(" + i.A() + ")");
    }

Answer 3

这是一个很好的问题。
所有的答案都可以在这里找到：
http://msdn.microsoft.com/en-us /library/6fawty39(VS.80).aspx

其要点是这样的：

...C# 编译器将首先尝试使
调用兼容版本
最初声明的 [functionName]
[派生类]。 覆盖方法不是
被视为在类上声明，
它们是一个新的实现
在基类上声明的方法。 仅有的
如果 C# 编译器无法匹配
方法调用原始方法
[派生类] 是否会尝试匹配调用
到具有相同覆盖的方法
名称和兼容参数。

因此，因为派生类上有一个与参数“c”匹配的新方法 Print(I i)（因为 c 实现了 I），所以该方法优先于“覆盖”方法。

当将方法标记为“new”时，它们都被视为在派生类上实现，并且 Print(C c) 方法与参数“c”更匹配，因此它优先。

Answer 4

这至少是一个关于 C# 中方法重载如何工作的问题。 我认为您在这里强调了一个有趣的情况...

在第一种情况下（在方法上使用 new 关键字），编译器决定使用 Print 方法重载使用类型 C 的参数，因为它的类型与传递的参数的类型完全相同（即不需要隐式转换），而如果编译器选择 Print，则需要隐式转换到接口 I code> 方法接受类型 I 的参数 - 换句话说，它选择更“明显”的方法重载。

在第二种情况下（在方法上使用 override 关键字），编译器决定使用带有 I 类型参数的 Print 重载，因为尽管您正在重写 B 类中的 >Print(C c) 方法重载，它在父类 A 中有效定义，使得 Print(I i) 方法重载实际上是最高级别的重载因此是最直接的，即编译器找到的第一个。

希望这能帮助您理解。 如果我需要进一步澄清任何要点，请告诉我...

注意：如果我错误地认为编译器会做这些事情，那么请纠正我，尽管从争论的角度来看，无论是编译器还是编译器都没有什么区别或者 CLR/JIT，看起来是这样。