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

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 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 where T : X { public D() { } } public static class X { } This will give compiler error: X': static classes cannot be used as constraints.

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 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 where T : X { public D() { } } public static class X { } This will give compiler error:'X': static classes cannot be used as constraints.

1 +1 - Would have never thought on this! – Konamiman Dec 22 '09 at 9:15 1 Generics is a way to use algorithms universally and to get better performance. So I slightly disagree with your point about inheritance.

– G2. Dec 22 '09 at 9:20 5 But there's absolutely now way that you could instantiate a C object of any type other than C. Because B is sealed it can have no subclasses, thus there is no other type that will match "where T : B". Therefore, the type T will always be B; otherwise, the constraint fails.

If your generic code is constrained so that it applies to exactly one type, is it still generic? :) – RAOF Dec 22 '09 at 9:54 Incidentally, if a class has two generic type parameters, one of which inherits from the other, it's perfectly acceptable for both parameters to be the same sealed class. Even though the fact that the second parameter is a sealed class would imply that the first parameter must be the same sealed class, there's no compiler complaint.

I think the basic reason for the complaint was to encourage people not to use generic type parameters which could only ever be one type. – supercat Aug 8 at 20:22.

Are you talking about something like this: class NonSealedClass { } class Test where T : NonSealedClass { } Because it's perfectly legal.

– this. __curious_geek Dec 22 '09 at 9:24 He mentioned using a non-sealed class as a generic constraint, I guess he probably meant a sealed class... – Aviad P. Dec 22 '09 at 9:45 It was my mistake he answered for my incorrect question.

– G2. Dec 22 '09 at 9:46.

Honestly, I don't quite see the point of it. As this. __curious_geek points out in his answer, a sealed class cannot be inherited and so using one as a constraint might seem nonsensical.

But there's no guarantee that a sealed class will never be "unsealed" -- i.e. , that the developer might rearrange its implementation to make it more amenable to inheritance and then remove the sealed modifier from the class definition (or just flat-out remove the sealed keyword for no reason at all). I know a lot of developers actually encourage this practice: not removing the sealed keyword per se, but rather adding the sealed keyword liberally and only supporting inheritance when the decision to do so is made explicitly (and at this point, yes, removing the sealed keyword).

So I'm not sure why you couldn't use the type of a sealed class as a generic constraint. After all, you could always use the type of a class that just happens to not have any derived classes, even though it's not sealed. The two scenarios don't seem all that different to me.

I'm probably missing something, though. I'm sure Eric Lippert could give a pretty killer explanation.

A naked constraint is where one generic type inherits from another e.g. Where X:Y One generic parameter derives from another generic parameter class Foo { Foo SubsetFoo() where S : T { } } So the class cannot be sealed. You can also inherit from generics in the normal way so you would not want them sealed.

Just FYI this appears to be a C# limitation but not an underlying . NET limitation.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.