Получение всех типов, которые реализуют интерфейс

Нет никакого простого способа (с точки зрения производительности), чтобы сделать то, что Вы хотите сделать.

Отражение работает с блоками и типами главным образом, таким образом, необходимо будет получить все типы блока и запросить их для правильного интерфейса. Вот пример:

Assembly asm = Assembly.Load("MyAssembly");
Type[] types = asm.GetTypes();
Type[] result = types.where(x => x.GetInterface("IMyInterface") != null);

, Который получит Вас все типы, которые реализуют IMyInterface в блоке MyAssembly

Вы могли использовать некоторый LINQ для получения списка:

var types = from type in this.GetType().Assembly.GetTypes()
            where type is ISomeInterface
            select type;

, Но действительно, который более читаем?

Редактирование: я только что видел редактирование, чтобы разъяснить, что исходный вопрос был для сокращения повторений / код, и это - все хорошо и хороший как осуществление, но в реальных ситуациях Вы собираетесь хотеть самую быструю реализацию, независимо от того, как прохладный базовый LINQ смотрит.

Вот мой метод Utils для итерации через загруженные типы. Это обрабатывает регулярные классы, а также интерфейсы, и excludeSystemTypes опция ускоряет вещи чрезвычайно при поиске реализаций в собственном / сторонняя кодовая база.

public static List<Type> GetSubclassesOf(this Type type, bool excludeSystemTypes) {
    List<Type> list = new List<Type>();
    IEnumerator enumerator = Thread.GetDomain().GetAssemblies().GetEnumerator();
    while (enumerator.MoveNext()) {
        try {
            Type[] types = ((Assembly) enumerator.Current).GetTypes();
            if (!excludeSystemTypes || (excludeSystemTypes && !((Assembly) enumerator.Current).FullName.StartsWith("System."))) {
                IEnumerator enumerator2 = types.GetEnumerator();
                while (enumerator2.MoveNext()) {
                    Type current = (Type) enumerator2.Current;
                    if (type.IsInterface) {
                        if (current.GetInterface(type.FullName) != null) {
                            list.Add(current);
                        }
                    } else if (current.IsSubclassOf(type)) {
                        list.Add(current);
                    }
                }
            }
        } catch {
        }
    }
    return list;
}

Это не симпатично, я признаю.

цикл посредством всех загруженных блоков, цикл через все их типы и проверка, если они реализуют интерфейс.

что-то как:

Type ti = typeof(IYourInterface);
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) {
    foreach (Type t in asm.GetTypes()) {
        if (ti.IsAssignableFrom(t)) {
            // here's your type in t
        }
    }
}

Для нахождения всех типов в блоке, которые реализуют интерфейс IFoo:

var results = from type in someAssembly.GetTypes()
              where typeof(IFoo).IsAssignableFrom(type)
              select type;

Примечание, что предложение Ryan Rinaldi было неправильным. Это возвратит 0 типов. Вы не можете записать

where type is IFoo

, потому что типом является Система. Введите экземпляр, и никогда не будет иметь типа IFoo. Вместо этого Вы проверяете, чтобы видеть, является ли IFoo присваиваемым от типа. Это получит Ваши ожидаемые результаты.

кроме того, предложение Adam Wright, которое в настоящее время отмечается как ответ, является неправильным также, и по той же причине. Во времени выполнения Вы будете видеть, что 0 типов возвращаются, потому что вся Система. Экземпляры типа не были конструкторами IFoo.

   public IList<T> GetClassByType<T>()
   {
        return AppDomain.CurrentDomain.GetAssemblies()
                          .SelectMany(s => s.GetTypes())
                          .ToList(p => typeof(T)
                          .IsAssignableFrom(p) && !p.IsAbstract && !p.IsInterface)
                          .SelectList(c => (T)Activator.CreateInstance(c));
   }