抽象类中的泛型类型和方法

Question

I am gonna start with the code and then the question. It is a more simple version than the actual code, though:

class SettingsItem<T>
{
}

class SettingsItemWhatever: SettingsItem<string>
{
}

Now the problem is that I want to have a class like, let's say:

class abstract SettingsContainer
{
}  

That will store objects of type SettingsItem and it's descendants, whatever the T is for each one of them, and so it will have a couple of Set and Get methods for those. Also it has to be an abstract class, so the work will be done in its descendants while this will only defined the methods those have to implement.

The problem arises when trying to code such methods. So far, and despite I tried some other approaches that resulted even more inconvenient, the best I found was this:

class abstract SettingsContainer
{
    public abstract Set<T> (T item);
    public abstract Get<T> (string key);
}

The problem with this approach is that you can call those functions with whatever parameter you want, and as far as they are abstract, they cannot do any testing on the parameter type, that's left to the descendants what it is suboptimal, since T has to be a SettingsItem or its descendant in any SettingsContainer derivated class.

Apart from that, I think there should be a way to tell the compiler the parameter has to be a descendant of SettingsItem, so it can check at compile time that the parameter type is OK, without having to check types at runtime instead.

Answer 1

You can create a non-generic base class for SettingsItem and specifiy it in a constraint, using the where keyword:

abstract class SettingsItem
{
    public string Key {get;}
}

class SettingsItem<T> : SettingsItem {

    public T Value {get;}
}

abstract class SettingsContainer {
    public abstract void Set<T>(T item) where T : SettingsItem;
    public abstract T Get<T> (string key) where T : SettingsItem;
}

Alternatively, you can just add another type parameter for including SettingsItem<T> in the constraint:

abstract class SettingsContainer {
    public abstract void Set<T,U>(T item) where T : SettingsItem<U>;
    public abstract T Get<T, U> (string key) where T : SettingsItem<U>;
}

Unless your actual use case needs the type to be a parameter, you might as well just include it in the method signature:

abstract class SettingsContainer {
    public abstract void Set<T>(SettingsItem<T> item);
    public abstract SettingsItem<T> Get<T> (string key);
}