Question

In C#, given a generic type such as this:

interface IGenericType<T> where T : new()

And a descendant type, such as:

class GenericTypeImplementation<U> : IGenericType<U>

Why do we need to explicitly restrict the generic type U with all the restrictions of the parent type?

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

Am I right in inferring that the issue is in the compiler computing the union of restrictions?

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

In my opinion, the compiler could be smart enough to infer the restrictions theoretically. But it shouldn’t be so smart, because a too-smart compiler is sometimes dangerous. Developers always need a clear/explicit definition of everything. See this scenario:

(1) there is an interface IFoo<T> where T : new()

(2) a class Foo<T> : IFoo<T> and the new() constraint is added automatically by the compiler(brilliant!)

(3) the class Foo<T> is a very base class in the whole project, class A<T> : Foo<T>, and then class B<T> : A<T>…

(4) Now another developer can hardly realize there is such a constraint by looking into the definition of the class, he will get weird compiling errors(well that’s acceptable). But what if they are invoked by reflection? Sometimes the program is correct, because the data meets the restriction by accident.