Why we can’t use sealed classes as generic constraints?

Question

Can you guess what is the reason to not allow sealed classes for type-constraints in generics? I only have one explanation is to give opportunity to use naked constraints.

Answer 1

If the class is sealed it cannot be inherited. If it cannot be inherited it'd be the only type valid for the generic type argument [assuming if allowed to be a type argument]. If it is the only generic type argument then there's no point in making it generic! You can simply code against the type in non-generic class.

Here's some code for this.

public class A {     public A() { } }  public sealed class B : A {     public B() { } }  public class C<T>         where T : B {     public C() { } } 

This will give compiler error: 'B' is not a valid constraint. A type used as a constraint must be an interface, a non-sealed class or a type parameter.

In addition to this, You can also not have a static class as generic type-constraint. The reason is simple. Static classes are marked as abstract and sealed in compiled IL which can be neither instantiated nor inherited.

Here's the code for this.

public class D<T>         where T : X {     public D() { } }  public static class X { } 

This will give compiler error:'X': static classes cannot be used as constraints.

Answer 2

Are you talking about something like this:

class NonSealedClass { }  class Test<T> where T : NonSealedClass { } 

Because it's perfectly legal.