I've been trying this, but I can't seem to figure this out. I want to do this...
public abstract class SingletonType<TSingleton, TBaseClass> : TBaseClass
where TSingleton : TBaseClass, new()
where TBaseClass : class
{
static TSingleton _singleton;
public static TSingleton Singleton
=> _singleton ?? (_singleton = new TSingleton());
}
The plan was to use it like this which would sort of 'wrap' the singleton pattern around a base class...
public class SingletonFoo : SingletonType<SingletonFoo, Foo> {
}
However, I keep getting this
Cannot derive from 'TBaseClass' because it is a type parameter
Um... I thought types were exactly what you do derive from!
So what am I missing?
Note: This is, of course, a trivial example as it doesn't add anything helpful, but assume SingletonType has a lot of other logic which isn't relative to the question, hence it was omitted to focus on the question at hand.
No, this is not possible. For example, take a type that is declared sealed. You can't inherit from that class, and there is no constraint to limit to non sealed types, ergo trying to inherit from it via a generic parameter is impossible.
Generic types in C# are not C++ templates; remember, a generic type must work for all possible type arguments. A template need only work for the constructions you actually make.
This question is a duplicate; see my answer to
Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates?
for more thoughts on this. Basically, the short answer is that the considerable costs do not outweigh the small benefits of the feature. If you don't like that answer, see my second answer:
Why cannot C# generics derive from one of the generic type parameters like they can in C++ templates?
And if you don't like that answer either, see the follow-up question:
What are the good reasons to wish that .NET generics could inherit one of the generic parameter types?
Every type has exactly 1 real, discrete parent class, even when generics are involved. Even when dealing with an open generic type (e.g., typeof(List<>)), you can still find the parent class.
If what you wanted were allowed, this would not be true, typeof(SingletonType<,> would not have a parent type, and this is not allowed.
No, it's not possible, because let's say you have this class:
class bar {
int example = 0;
}
Now here's our type parameter class:
class foo<T> : T {
int example = 5;
}
If we created a variable of type foo<bar> then example would get mixed up.
