Store a list/dictionary of generic object

Question

I would like to know if there is way to store in a Dictionary/List/... of a generic type.

Let's imagine this class:

public class Registry{
    private Dictionary<String, MyGenericType<IContainableObject>> m_elementDictionary = new Dictionary<String, MyGenericType<IContainableObject>>();

    public void Register<T>(MyGenericType<T> objectToRegister)
    where T: IContainableObject
    {
        m_elementDictionary[objectToRegister.key] = objectToRegister; //This doesn't work
    }
}

I don't understand why we can't add this element to the Dictionary since we know that the argument we receive with a generic type is in fact a MyGenericType<IContainableObject> due to the where condition.

Please note:

1. I know that I can put an interface on MyGenericType<IContainableObject> a store a dictionary of this. This is the subject.
2. I know that I can have an MyGenericType<IContainableObject>argument, this is the point either.

I was more looking if the covariance/contravariance can help here?

Answer 1

You should express the where condition like this:

public void Register<T>(T objectToRegister)
    where T : MyGenericType<IContainableObject> {
    m_elementDictionary[objectToRegister.key] = objectToRegister;
}

Moreover, you should define MyGenericType to be covariant, as in this example:

interface IContainableObject { 
}

public interface MyGenericType<out T> {
    string key();
}

interface IDerivedContainableObject : IContainableObject {
}

class Program {

    private static Dictionary<String, MyGenericType<IContainableObject>> m_elementDictionary = new Dictionary<String, MyGenericType<IContainableObject>>();

    public static void Register<T>(T objectToRegister)
        where T : MyGenericType<IContainableObject> {
            m_elementDictionary[objectToRegister.key()] = objectToRegister;
    }

    static void Main(string[] args) {
        MyGenericType<IDerivedContainableObject> x = null;
        MyGenericType<IContainableObject> y = x;
        Register(y);
    }

}

(Note that MyGenericType is now an interface)

Answer 2

The reason this won't work is because the C# standard defines generics to be invariant [1]. This means that if we have a base class (or interface) B and a derived class D then we can say the followings:

• D is a subtype of B
• D[] is a subtype of B[]
• BUT G<D> is not a subtype of G<B> where G is any generic type.

The compiler will try to do an implicit conversion between two invariant types G<D> and G<B> and surely will fail since no conversion is defined there.

And this happens to be your case as well since you are trying to convert from MyGenericType<some_object> to MyGenericType<IContainableObject>.

Note that semantically speaking this actually makes sense since you are not really converting from a derived class to a base class but more between two generic types.

Same behavior can be noticed with lists:

List<D> base_list = new List<D>(); //this will give an error message

I am unware of your specific requirements to give relevant suggestions, but in most cases I would most likely go with hiding this implemention under an interface and storing those interfaces in the dictionary (what you already mentioned it). This will provide a free decoupling as well.

---

References

[1] Generic type parameter variance in the CLR

Answer 3

I'm not sure this will be clear, but its working:

public interface IContainableObject 
{ 
}

public interface IMyGenericType<in T> 
    where T:IContainableObject
{
    string key{get;set;}
}

public abstract class MyGenericType<T> : IMyGenericType<IContainableObject>
    where T : IContainableObject
{
    public string key{get;set;}
}

public class MyTypedClass:MyGenericType<DerivedContainableObject>
{

}

public class DerivedContainableObject:IContainableObject
{
}



public class Registry

{
    private Dictionary<String, IMyGenericType<IContainableObject>> m_elementDictionary = new Dictionary<String, IMyGenericType<IContainableObject>>();

    public void Register<T>(MyGenericType<T> objectToRegister)       
        where T:IContainableObject
    {
        m_elementDictionary[objectToRegister.key] = objectToRegister; //This now work
    }

    public void ExampleMethod() 
    {
        Register<DerivedContainableObject>(new MyTypedClass());
    }
}