这对我很管用。它循环遍历这些类并检查它们是否派生自myInterface

 foreach (Type mytype in System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
                 .Where(mytype => mytype .GetInterfaces().Contains(typeof(myInterface)))) {
    //do stuff
 }

其他答案是没有使用通用接口。

这一个做到了，只是用typeof(T)替换typeof(ISomeInterface)。

List<string> types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes())
            .Where(x => typeof(ISomeInterface).IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract)
            .Select(x => x.Name).ToList();

所以,

AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes())

我们得到了所有的集合

!x.IsInterface && !x.IsAbstract

是用来排除接口和抽象的和

.Select(x => x.Name).ToList();

把它们列在一个列表里。

遍历所有加载的程序集，遍历它们的所有类型，并检查它们是否实现了接口。

喜欢的东西:

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是否可以从类型中赋值。这将得到你预期的结果。

此外，亚当·赖特的建议，目前被标记为答案，也是不正确的，出于同样的原因。在运行时，您将看到返回0类型，因为所有System。类型实例不是IFoo实现者。

我在这里看到了太多过于复杂的答案，人们总是告诉我，我倾向于把事情复杂化。同样使用IsAssignableFrom方法来解决OP问题也是错误的!

下面是我的例子，它从应用程序域中选择所有程序集，然后它采用所有可用类型的平面列表，并检查每个类型的接口列表是否匹配:

public static IEnumerable<Type> GetImplementingTypes(this Type itype) 
    => AppDomain.CurrentDomain.GetAssemblies().SelectMany(s => s.GetTypes())
           .Where(t => t.GetInterfaces().Contains(itype));

我知道这是一个非常老的问题，但我想我将为未来的用户添加另一个答案，因为迄今为止所有的答案都使用某种形式的Assembly.GetTypes。

虽然GetTypes()确实会返回所有类型，但这并不一定意味着您可以激活它们，从而可能会抛出一个reflectiontypeloadeexception异常。

无法激活类型的典型示例是，当返回的类型是从base派生的，但base定义在与派生的不同的程序集中，调用程序集没有引用该程序集。

假设我们有:

Class A // in AssemblyA
Class B : Class A, IMyInterface // in AssemblyB
Class C // in AssemblyC which references AssemblyB but not AssemblyA

如果在AssemblyC中的ClassC中，我们按照接受的答案做一些事情:

var type = typeof(IMyInterface);
var types = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(s => s.GetTypes())
    .Where(p => type.IsAssignableFrom(p));

然后它将抛出一个reflectiontypeloadeexception异常。

这是因为在AssemblyC中没有对AssemblyA的引用，您将无法:

var bType = typeof(ClassB);
var bClass = (ClassB)Activator.CreateInstance(bType);

换句话说，ClassB是不可加载的这是GetTypes调用检查并抛出的东西。

因此，为了安全地限定结果集为可加载类型，然后根据Phil haked的文章在一个程序集中获取所有类型和Jon Skeet代码，你会做这样的事情:

public static class TypeLoaderExtensions {
    public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly) {
        if (assembly == null) throw new ArgumentNullException("assembly");
        try {
            return assembly.GetTypes();
        } catch (ReflectionTypeLoadException e) {
            return e.Types.Where(t => t != null);
        }
    }
}

然后:

private IEnumerable<Type> GetTypesWithInterface(Assembly asm) {
    var it = typeof (IMyInterface);
    return asm.GetLoadableTypes().Where(it.IsAssignableFrom).ToList();
}