Question

I’m trying to store types in a collection, so that i can later instantiate objects of the types in the collection. But I’m not sure how to do this the best way.

What i have so far:

List<Type> list = new List<Type>();
list.Add(typeof(MyClass));
var obj = (MyClass)Activator.CreateInstance(list[0]);

I would like to have some constrains on the Type, or better yet, just a generic type in the collection instead of an instantiated Type object. Is this possible?

Answer 1

In this particular scenario, where it seems we have a “factory” pattern, we would constrain the method invoking the activator, such as

private readonly List<Type> _supportedTypes = new List<Type> ();
public void RegisterSupportedType<T> () where T : SomeConstraintType
{
    _supportedTypes.Add (typeof (T));
}

// if we do not know the type, but somehow know an index to type
public object Create (int supportedTypeIndex)
{
    object untyped = Activator.
        CreateInstance (_supportedTypes[supportedTypeIndex]);
    return untyped;
}

// if we know instance type\subtype (eg interface) and know an index
public T Create<T> (int supportedTypeIndex)
{
    T typed = default (T);
    object untyped = Create (supportedTypeIndex);
    if (!(untyped is T))
    {
        // throw meaningful exception :)
    }
    typed = (T)(untyped);
    return typed;
}

An alternative, is to create a constrained Type

public class ConstrainedType<T> 
{
    public Type Type { get; private set; }
    public ConstrainedType (Type type)
    {
        // may have this backward, would have to fact check before
        // rolling out to prod ;)
        if (!typeof (T).IsAssignableFrom (type))
        {
            // throw meaningful exception!
        }
        Type = type;
    }
}

List<ConstrainedType<SomeTypeConstraint>> list = 
    new List<ConstrainedType<SomeTypeConstraint>> ();

// will throw meaningful exception if MyClass is not 
// SomeTypeConstraint or a sub class
list.Add (new ConstrainedType (typeof (MyClass)));

SomeTypeConstraint baseType = 
    (SomeTypeConstraint)(Activator.CreateInstance(list[0].Type));