在 C# 中跨继承边界重载

读完这篇文章和那篇文章后，我感到困惑。

它说：

如果层次结构的不同级别有两个方法，则 "更深"的将首先被选择，即使它不是一个"更好的功能 成员"的呼叫。

也-

事实证明，如果您重写子级中的基类方法 类，这不算声明它。

现在让我们回到我的问题：

案例1

    public class Base
     {
           public virtual void  Foo(int x)  { "1".Dump();}
     }
    public class Child : Base
     {
          public void Foo(object x) { "3".Dump();}  
          public override void  Foo(int x)  { "2".Dump();}
     }

void Main()
{
    Child c = new Child();
    c.Foo(10); //emits 3
}

还行。根据文章

"

更深"的将首先被选择，即使它不是一个"更好的功能。而且它不计算覆盖...

所以这是正确的，程序发出"3"。（Foo(object x)被执行）

让我们更改 1 行的行顺序：

案例2

          public class Base
         {
                 public virtual void  Foo(int x)  { "1".Dump();}
                 public void Foo(object x) { "3".Dump();} //<line being moved here
         }
        public class Child : Base
         {
              public override void  Foo(int x)  { "2".Dump();}
         }

    void Main()
    {
        Child c = new Child();
        c.Foo(10); //emits 2 !!!!
    }

现在它发出"2"。

现在让我们将所有 int 更改为对象，将所有对象更改为 int：

案例3

      public class Base
    {
      public virtual void  Foo(object x)  { "1".Dump();}
      public void Foo(int x) { "3".Dump();} 
    }
    public class Child : Base
    {
         public override void  Foo(object x)  { "2".Dump();}
    }

void Main()
{
    Child c = new Child();
    c.Foo(1); //emits "3"
}

问题 ：

---

问题#1：在案例2中，Child从其父亲那里继承了Foo(object x)，并且他还覆盖了一个方法。

但我们刚才不是说的吗：

事实证明，如果您重写子级中的基类方法 类，这不算声明它

???

事实上，我们也没有声明继承的函数......那么在这种情况下的规则是什么？

---

问题#2：在案例3中，Child从其父亲那里继承了Foo(int x)，并且他还覆盖了一个方法。

但是现在，他选择了它的父亲功能。

似乎override只有在完全匹配的情况下才能获胜。

再说一次，在这种情况下的规则是什么？

---

virtual void Foo(int x) // Base
void Foo(object x) // Base
override void Foo(int x) // Child

virtual void Foo(int x) // Base
void Foo(object x) // Base

virtual void Foo(int x) // Base

override void Foo(int x) // Child

public class A
{
  public virtual void Foo()
  {
    Console.WriteLine("A.Foo() called");
  }
}
public class B: A
{
  public override void Foo()
  {
    Console.WriteLine("B.Foo() called");
  }
}
void Main()
{
new B().Foo();
}