为什么必须对后代类型重新声明泛型类型限制？

Question

在 C# 中，给定一个像这样的泛型类型：

interface IGenericType<T> where T : new()

和一个后代类型，例如：

class GenericTypeImplementation<U> : IGenericType<U>

为什么我们需要用父类型的所有限制显式地限制泛型类型 U ？

class GenericTypeImplementation<U> : IGenericType<U> where U : new()

我是否正确推断问题出在编译器计算限制并集上？

interface IGenericType<T> where T : new()
interface IGenericType2<T> where T : SomeOtherType
class GenericTypeImplementation<U> : IGenericType<U>, IGenericType2<U>
/* Hypothesis: Compiler can't infer U must be "SomeOtherType + new()" */

Answer 1

在我看来，编译器可能足够聪明，可以从理论上推断出这些限制。但它不应该这么聪明，因为过于聪明的编译器有时是危险的。开发人员总是需要对所有事物都有清晰/明确的定义。请看这个场景：

(1) 有一个接口 IFoo；其中 T : new()

(2) 一个 Foo类； : IFoo和 new() 约束由编译器自动添加（太棒了！）

(3) 类 Foo 是一个整个项目中非常基类，class A: Foo，然后class B; : A...

(4) 现在另一个开发人员很难通过查看类的定义来意识到存在这样的约束，他会得到奇怪的编译错误（好吧，这是可以接受的）。但是如果它们是通过反射调用的呢？有时程序是正确的，因为数据偶然满足了限制。

Answer 2

编译器能够推断 U 必须可转换为 SomeOtherType 并且必须具有默认构造函数。它将为每个约束生成一个编译器错误：

Error   1   The type 'U' must have a public parameterless constructor in order to use it as parameter 'T' in the generic type or method '....IGenericType<T>'
Error   2   The type 'U' must be convertible to '....SomeOtherType' in order to use it as parameter 'T' in the generic type or method '....IGenericType2<T>'

仅实现其中一个接口时也会发生这种情况。该类必须成功实现两个接口才能进行编译：

class GenericTypeImplementation<U> : IGenericType<U>, IGenericType2<U>
    where U : SomeOtherType, new()
{...}

或作为非泛型类型：

class GenericTypeImplementation : IGenericType<SomeType>, IGenericType2<SomeOtherType>
{...}

将类标记为实现接口并不是对类的泛型类型参数指定约束的方法；而是将类标记为实现接口。这是一种要求新类型参数存在这些约束或者所提供的类型满足这些约束的方式。

也许您可以这样想：接口是一组受约束的类，泛型类也是一组受约束的类。通用接口是一组受约束的通用类。当您说泛型类实现泛型接口时，您是在询问编译器：“这个泛型类是否严格位于该泛型接口指定的集合内？”您不仅仅是将它们作为一组进一步受限的类进行交叉。

Answer 3

因为泛型类型限制是针对定义类的类型参数（示例中的 U），所以从 CLR 的角度来看，它与接口的类型参数是不同的类型。

类的类型参数不必是接口的实际类型参数。它甚至不需要是一个简单的类型，如下所示：

class Implementation<T> : IGenericType<List<T>> { /* ... */ }

在这种情况下，编译器识别出 List 满足约束，因此不需要进一步的规范。但是，如果不了解泛型类型参数，编译器就会要求您显式声明它。

将此与泛型方法的类似但不相同的行为进行比较是有启发性的。与实现接口的类一样，必须在声明中指定类型限制。有一个值得注意的例外：如果实现是显式的。事实上，当您尝试重新施加限制时，编译器会生成错误。

例如，给定一个接口，

interface ISomething {
    void DoIt<T>() where T : new();
}

实现该接口的两种正确方法是：

class OneThing : ISomething {
    public void DoIt<T>() where T : new() { }
}

class OtherThing : ISomething {
    void ISomething.DoIt<T>() { }
}

在 OneThing 中省略约束或将其插入到 OtherThing 中会产生编译时错误。为什么我们在第一个实现中需要约束，而不是在第二个实现中？我想说的是，出于与上面提到的接口类型约束相同的原因：在第一个实现中，类型 T 与接口方法上的类型参数没有关系，因此必须将其明确化使方法与接口方法相匹配。在第二个实现中，我们显式声明接口意味着类型参数 T 与接口中使用的类型参数完全相同。