c# - 泛型方法不调用类型为 'T' 的方法

Question

假设我有两个类:

class a
{
    public void sayGoodbye() { Console.WriteLine("Tschüss"); }
    public virtual void sayHi() { Console.WriteLine("Servus"); }
}

class b : a
{
    new public void sayGoodbye() { Console.WriteLine("Bye"); }
    override public void sayHi() { Console.WriteLine("Hi"); }
}

如果我调用一个需要从类“a”派生类型“T”的泛型方法:

void call<T>() where T : a

然后在该方法中，我在类型“T”的实例上调用方法，方法调用绑定(bind)到类型“a”，就好像该实例被转换为“a”一样:

call<b>();
...
void call<T>() where T : a
{
    T o = Activator.CreateInstance<T>();
    o.sayHi(); // writes "Hi" (virtual method)
    o.sayGoodbye(); // writes "Tschüss"
}

通过使用反射，我能够得到预期的结果:

call<b>();
...
void call<T>() where T : a
{
    T o = Activator.CreateInstance<T>();
    // Reflections works fine:
    typeof(T).GetMethod("sayHi").Invoke(o, null); // writes "Hi"
    typeof(T).GetMethod("sayGoodbye").Invoke(o, null); // writes "Bye"
}

此外，通过使用类“a”的接口(interface)，我得到了预期的结果:

interface Ia
{
    void sayGoodbye();
    void sayHi();
}
...
class a : Ia // 'a' implements 'Ia'
...
call<b>();
...
void call<T>() where T : Ia
{
    T o = Activator.CreateInstance<T>();
    o.sayHi(); // writes "Hi"
    o.sayGoodbye(); // writes "Bye"
}

等效的非通用代码也可以正常工作:

call();
...
void call()
{
    b o = Activator.CreateInstance<b>();
    o.sayHi(); // writes "Hi"
    o.sayGoodbye(); // writes "Bye"
}

如果我将通用约束更改为“b”，结果相同:

call<b>();
...
void call<T>() where T : b
{
    T o = Activator.CreateInstance<T>();
    o.sayHi(); // writes "Hi"
    o.sayGoodbye(); // writes "Bye"
}

编译器似乎正在生成对约束中指定的基类的方法调用，所以我想我明白发生了什么，但这不是我所期望的。这真的是正确的结果吗？

Answer 1

泛型不是 C++ 模板

泛型是一种通用类型:编译器只会输出一个泛型类(或方法)。泛型无法通过编译时替换 T 来工作使用提供的实际类型，这将需要为每个类型参数编译一个单独的通用实例，而是通过使一个类型具有空“空白”来工作。在通用类型中，编译器然后在不知道特定参数类型的情况下继续解决对这些“空白”的操作。因此，它使用它已经拥有的唯一信息；即除了全局事实(例如一切皆对象)之外您提供的约束。

所以当你说...

void call<T>() where T : a {
    T o = Activator.CreateInstance<T>();
    o.sayGoodbye();//nonvirtual

...然后输入 T的 o 仅在编译时相关 - 运行时类型可能更具体。在编译时，T本质上是 a 的同义词- 毕竟，这就是编译器对 T 的全部了解!因此请考虑以下完全等效的代码:

void call<T>() where T : a {
    a o = Activator.CreateInstance<T>();
    o.sayGoodbye();//nonvirtual

现在，调用非虚拟方法会忽略变量的运行时类型。正如预期的那样，您会看到 a.sayGoodbye()被称为。

相比之下，C++ 模板确实按照您期望的方式工作——它们实际上在编译时扩展了模板，而不是用“空白”进行单一定义，因此特定的模板实例可以使用仅适用于该专业的方法。事实上，即使在运行时，CLR 也会避免实际实例化模板的特定实例:因为所有调用要么是虚拟的(无需显式实例化)，要么是特定类的非虚拟(同样，实例化没有意义)，CLR 可以使用相同的字节——甚至可能是相同的 x86 代码——来覆盖多种类型。这并不总是可行的(例如对于值类型)，但对于节省内存和 JIT 时间的引用类型。

还有两件事...

首先，您的调用方法使用Activator - 没有必要；有一个特殊的约束 new()您可以改用它做同样的事情，但带有编译时检查:

void call<T>() where T : a, new() {
    T o = new T();
    o.sayGoodbye();

正在尝试编译 call<TypeWithoutDefaultConstructor>()将在编译时失败并显示人类可读的消息。

其次，如果泛型只是空白，那么看起来好像泛型在很大程度上毫无意义 - 毕竟，为什么不简单地在 a 上工作呢？类型变量一直？好吧，虽然在编译时你不能依赖任何细节 a 的子类可能在 通用方法中，您仍然强制执行所有 T属于相同子类，特别允许使用众所周知的容器，例如List<int> - 即使List<>永远不能依赖int内部，给 List<> 的用户避免转换(以及相关的性能和正确性问题)仍然很方便。

泛型还允许比普通参数更丰富的约束:例如，您通常不能编写要求其参数同时是 a 子类型的方法。和 IDisposable - 但您可以对一个类型参数设置多个约束，并将一个参数声明为该泛型类型。

最后，泛型可能有运行时差异。您调用Activator.CreateInstance<T>()是一个完美的例子，简单的表达式 typeof(T) 就是这样。或 if(myvar is T)... .因此，即使在某种意义上编译器“认为”了 Activator.CreateInstance<T>() 的返回类型作为a在编译时，在运行时对象的类型为 T .