Is it possible to get an instance of every class that inherits from an interface?

Question

I have a small project that I'm making, and I'm trying to figure out if it's possible to get an instance of every class that inherits from a particular interface.

Here's a simplified example of what I'm trying to accomplish:

public interface IExample
{
    string Foo();
}

public class Example1 : IExample
{
    public string Foo()
    {
        return "I came from Example1 !";
    }
}

public class Example2 : IExample
{
    public string Foo()
    {
        return "I came from Example2 !";
    }
}

//Many more ExampleN's go here

public class ExampleProgram
{

    public static void Main(string[] args)
    {
        var examples = GetExamples();

        foreach (var example in examples)
        {
            Console.WriteLine(example.Foo());
        }
    }

    public static List<IExample> GetExamples()
    {
        //What goes here?
    }
}

Is there any way (short of hard-coding it) for the GetExamples method to return a list containing an instance of each class inheriting from the interface IExample? Any insight you can give would be much appreciated.

Answer 1

See: http://stackoverflow.com/questions/457676/c-reflection-check-if-a-class-is-derived-from-a-generic-class

Also: http://stackoverflow.com/questions/80247/implementations-of-interface-through-reflection (this may be exactly what you want)

You will basically just need to enumerate through every type in the target assembly and test to see if it implements the interface.

Answer 2

You will have to use reflection.

Assembly.GetExecutingAssembly should be your starting point.

EDIT: Code that should help

Type[] types = Assembly.GetExecutingAssembly().GetTypes();
foreach(Type tp in types)
{
 if (typeof(IExample).IsAssignableFrom(tp))
 {
  if (tp.IsInterface == false)
  {
   IExample t = Activator.CreateInstance(tp) as IExample;
   Console.WriteLine(t.Foo());
  }
 }
}

Answer 3

Here's how I'd do something like that:

    public static List<IExample> GetExamples()
    {
        var assembly = Assembly.GetExecutingAssembly();
        var types = assembly.GetTypes().Where(t => t.GetInterfaces().Any(i => i == typeof(IExample))).ToList();

        List<IExample> returnMe = new List<IExample>();
        foreach (var type in types)
            returnMe.Add((IExample) Activator.CreateInstance(type));

        return returnMe;
    }

Answer 4

Building upon Matt's solution, I would implement it something like this:

public static List<IExample> GetExamples()
{
    return GetInstances<IExample>().ToList();
}

private static IEnumerable<T> GetInstances<T>()
{
    return Assembly.GetExecutingAssembly().GetTypes()
        .Where(type => type.IsClass &&
                       !type.IsAbstract &&
                       type.GetConstructor(Type.EmptyTypes) != null &&
                       typeof (T).IsAssignableFrom(type))
        .Select(type => (T) Activator.CreateInstance(type));
}

This solution skips types that cannot be instantiated such as abstract classes, derived interfaces and classes without default (parameterless) public constructors.