C# 和泛型 - 为什么调用基类中的方法而不是派生类中的新方法？

Question

如果泛型类型参数（调用类或调用方法）受where T : Base 约束，则不会调用 T == Derived 中的新方法，而是调用 Base 中的方法。

为什么类型 T 被方法调用忽略了，即使它应该在运行时之前知道？

更新：但是，当约束使用像where T : IBase 这样的接口时，会调用基类中的方法（而不是接口中的方法，这也是不可能的）。
这意味着系统实际上能够检测到远远超出类型约束的类型！那么为什么在类类型约束的情况下它不超出类型约束呢？
这是否意味着实现该接口的基类中的方法具有该方法的隐式覆盖关键字？

测试代码：

public interface IBase
{
    void Method();
}

public class Base : IBase 
{
    public void Method()
    {

    }
}

public class Derived : Base
{
    public int i = 0;

    public new void Method()
    {
        i++;
    }
}

public class Generic<T>
    where T : Base
{
    public void CallMethod(T obj)
    {
        obj.Method();  //calls Base.Method()
    }

    public void CallMethod2<T2>(T2 obj)
        where T2 : T
    {
        obj.Method();  //calls Base.Method()
    }
}

public class GenericWithInterfaceConstraint<T>
    where T : IBase
{
    public void CallMethod(T obj)
    {
        obj.Method();  //calls Base.Method()
    }

    public void CallMethod2<T2>(T2 obj)
        where T2 : T
    {
        obj.Method();  //calls Base.Method()
    }
}

public class NonGeneric
{
    public void CallMethod(Derived obj)
    {
        obj.Method();  //calls Derived.Method()
    }

    public void CallMethod2<T>(T obj)
        where T : Base
    {
        obj.Method();  //calls Base.Method()
    }

    public void CallMethod3<T>(T obj)
        where T : IBase
    {
        obj.Method();  //calls Base.Method()
    }
}

public class NewMethod
{
    unsafe static void Main(string[] args)
    {
        Generic<Derived> genericObj = new Generic<Derived>();
        GenericWithInterfaceConstraint<Derived> genericObj2 = new GenericWithInterfaceConstraint<Derived>();
        NonGeneric nonGenericObj = new NonGeneric();
        Derived obj = new Derived();

        genericObj.CallMethod(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        genericObj.CallMethod2(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        genericObj2.CallMethod(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        genericObj2.CallMethod2(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        nonGenericObj.CallMethod(obj);  //calls Derived.Method()
        Console.WriteLine(obj.i);

        nonGenericObj.CallMethod2(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        nonGenericObj.CallMethod3(obj);  //calls Base.Method()
        Console.WriteLine(obj.i);

        obj.Method();  //calls Derived.Method()
        Console.WriteLine(obj.i);
    }
}

输出：

0
0
0
0
1
1
1
2

Answer 1

除了使用dynamic 对象时，C# 总是在编译时绑定方法——即使在使用泛型时也是如此。虚拟方法调用绑定到虚拟方法槽而不是实现方法，因此当它们在派生类对象上执行时，它们将被定向到派生类实现；虽然插槽指向的方法将在运行时确定，但与插槽的绑定发生在编译时。如果派生类方法声明为new 而不是override，则使用派生类绑定的代码将使用派生类方法，但使用基类绑定的代码将使用基类方法。

要理解为什么会这样，想象一下如果不是这样。如果类Base 声明了一个方法int Foo()，而一个类Derived:Base 声明了一个new string Foo()，会发生什么。如果具有约束T:Base 的泛型类尝试在T 类型的对象上调用方法Foo，该方法的返回类型应该是什么？

Answer 2

这是因为T 被限制为具有Base 的语义。我无法准确告诉您类型绑定在运行时发生了什么，但这是我有根据的猜测。

您没有正确覆盖该方法，而是通过“new”隐藏，如果您使用对基类的引用，您将绕过任何隐藏。这就是隐藏失败的地方。

隐藏其他成员的成员只有在您使用对隐藏它们的类型的引用时才会受到尊重。您始终可以通过使用对基类的引用来绕过隐藏成员：

var derived = new Derived();
var baseRef = (Base)derived;
baseRef.Method(); // calls Base.Method instead of Derived.Method.

要正确覆盖方法并让此代码正常工作，请在基类中将该方法标记为virtual，在派生类中将其标记为override。

class Base
{
    public virtual void Method() {}
}

class Derived : Base
{
    public override void Method() {}
}

您可以证明这一点，将您的通用约束更改为where T : Derived，它应该会命中“新”成员。

Answer 3

这是由于运算符 new 的性质造成的： 新的不像覆盖，创建一个与基本方法同名的函数，它掩盖基本方法但不覆盖它。

因此，如果没有适当的转换，如果引用是 Base 类型，则将调用原始方法。

Answer 4

new 关键字只是隐藏方法而不是重载它。您的非泛型CallMethod 似乎按预期工作的原因是因为方法签名需要Derived 而不是Base。

泛型并不是真正的罪魁祸首。如果您将方法签名更改为CallMethod(Base obj)，您将看到与通用实现相同的“意外”行为并获得以下输出：

0
0
0
0
0
0
0
1

如果您将Base.Method 设为虚拟并用Derived.Method 覆盖它，如下所示：

public class Base 
{
    public virtual void Method()
    {

    }
}

public class Derived : Base
{
    public int i = 0;

    public override void Method()
    {
        i++;
    }
}

您将获得以下输出：

1
2
3
4
5
6
7
8

编辑：已更新以匹配问题的更新输出。