考虑以下代码片段:

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(object o)
    {
        Console.WriteLine("Derived.Foo(object)");
    }
}

public class Program
{
    public static void Main()
    {
        Derived d = new Derived();
        int i = 10;
        d.Foo(i);
    }
}

令人惊讶的输出是:

Derived.Foo(object)

我希望它选择覆盖的 Foo(int x) 方法，因为它更具体。但是，C# 编译器会选择非继承的 Foo(object o) 版本。这也导致装箱操作。

这种行为的原因是什么？

最佳答案

这是规则，你可能不喜欢...

Quote from Eric Lippert

if any method on a more-derived class is an applicable candidate, it is automatically better than any method on a less-derived class, even if the less-derived method has a better signature match.

原因是因为该方法(更好的签名匹配)可能已添加到更高版本中，因此引入了“brittle base class”故障

注意:这是 C# 规范中相当复杂/深入的部分，它到处都是。但是，您遇到的问题的主要部分如下所示

更新

这就是我喜欢 stackoverflow 的原因，它是一个学习的好地方。

我引用了有关方法调用的运行时处理 的部分。因为问题是关于编译时重载解决方案，而且应该是。

7.6.5.1 Method invocations

...

The set of candidate methods is reduced to contain only methods from the most derived types: For each method C.F in the set, where C is the type in which the method F is declared, all methods declared in a base type of C are removed from the set. Furthermore, if C is a class type other than object, all methods declared in an interface type are removed from the set. (This latter rule only has affect when the method group was the result of a member lookup on a type parameter having an effective base class other than object and a non-empty effective interface set.)

请看 Eric 的回复 https://stackoverflow.com/a/52670391/1612975有关这里发生的事情和规范的适当部分的完整详细信息

原创

C# 语言规范 5.0版本

7.5.5 Function member invocation

...

The run-time processing of a function member invocation consists of the following steps, where M is the function member and, if M is an instance member, E is the instance expression:

...

If M is an instance function member declared in a reference-type:

• E is evaluated. If this evaluation causes an exception, then no further steps are executed.
• The argument list is evaluated as described in §7.5.1.
• If the type of E is a value-type, a boxing conversion (§4.3.1) is performed to convert E to type object, and E is considered to be of type object in the following steps. In this case, M could only be a member of System.Object.
• The value of E is checked to be valid. If the value of E is null, a System.NullReferenceException is thrown and no further steps are executed.
• The function member implementation to invoke is determined:
  • If the binding-time type of E is an interface, the function member to invoke is the implementation of M provided by the run-time type of the instance referenced by E. This function member is determined by applying the interface mapping rules (§13.4.4) to determine the implementation of M provided by the run-time type of the instance referenced by E.
  • Otherwise, if M is a virtual function member, the function member to invoke is the implementation of M provided by the run-time type of the instance referenced by E. This function member is determined by applying the rules for determining the most derived implementation (§10.6.3) of M with respect to the run-time type of the instance referenced by E.
  • Otherwise, M is a non-virtual function member, and the function member to invoke is M itself.

阅读规范后有趣的是，如果您使用描述该方法的接口(interface)，编译器将选择重载签名，然后按预期工作

  public interface ITest
  {
     void Foo(int x);
  }

Which can be shown here

关于接口(interface)，考虑到为防止 Brittle 基类而实现的重载行为确实有意义

其他资源

Eric Lippert, Closer is better

The aspect of overload resolution in C# I want to talk about today is really the fundamental rule by which one potential overload is judged to be better than another for a given call site: closer is always better than farther away. There are a number of ways to characterize “closeness” in C#. Let’s start with the closest and move our way out:

• A method first declared in a derived class is closer than a method first declared in a base class.
• A method in a nested class is closer than a method in a containing class.
• Any method of the receiving type is closer than any extension method.
• An extension method found in a class in a nested namespace is closer than an extension method found in a class in an outer namespace.
• An extension method found in a class in the current namespace is closer than an extension method found in a class in a namespace mentioned by a using directive.
• An extension method found in a class in a namespace mentioned in a using directive where the directive is in a nested namespace is closer than an extension method found in a class in a namespace mentioned in a using directive where the directive is in an outer namespace.

关于C# 方法重写分辨率异常，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52661927/