Question

is there any possibility to have a generic List<System.Type> and to have a constraint on the type?
I want to store types in a list for a lookup, but only types where the class of this type implements a specific interface.

Something like this:

List<Type> : where typeof(Type) is IMyClass

Is that possible? If not do you have any suggestion on how to solve this issue?

Any help appreciated !

EDIT:

Sorry I haven’t been clearer on the subject, but Sign’s comment below is correct, I don’t have instances available, just types.

Assume the following:

class PluginA : IPlugin { } 
class PluginB : IPlugin { } 
class PluginC : ISomeOtherInterface { } 

var pluginTypes = new List<Type>()
pluginTypes.Add(typeof(PluginA) --> OK
pluginTypes.Add(typeof(PluginB) --> OK
pluginTypes.Add(typeof(PluginC) --> should fail

Yes I could wrap this, but hoped that there would be a better variant which checks during compiletime or hints with intellisense what types are allowed.

Answer 1

if I understood you correctly, you want a list of System.Type which checks that its elements implement a certain interface. This is easy to accomplish. Just implement IList<Type> by wrapping most the List<Type> functionality and add a couple of checkups.

public class TypeFilteredList : IList<Type>
{
    private Type filterType;
    private List<Type> types = new List<Type>();

    public TypeFilteredList(Type filterType)
    {
        this.filterType = filterType;
    }

    private void CheckType(Type item)
    {
        if (item != null && !filterType.IsAssignableFrom(item))
            throw new ArgumentException("item");
    }

    public void Add(Type item)
    {
        CheckType(item);
        types.Add(item);
    }

    public void Insert(int index, Type item)
    {
        CheckType(item);
        types.Insert(index, item);
    }

…

}

this code will work for base classes as well as interfaces.

Example usage:

TypeFilteredList list = new TypeFilteredList(typeof(IInterface));
list.Add(typeof(Implementation));
list.Add(typeof(int)); // ArgumentException

If you however don’t need IList functionality, you can implement IEnumerable<Type> or ISet<Type> (wrapping HashSet<T>). List leaves an option to add the same type several times, which it seems to me is something, you don’t want.