如何在不加载程序集的情况下判断其是否实现指定接口并返回实现类列表

我明白你的需求——你想在不加载目标程序集的前提下，检查它是否包含实现了指定接口的公共具体类，并且返回这些类的列表。其实你已经用PEReader和MetadataReader走对了方向，核心问题就是如何把Metadata里的接口引用和你指定的泛型接口类型做匹配，下面我来一步步帮你解决这个问题：

核心思路 #

1. 先获取你要检查的目标接口的完整名称（命名空间+类名），这是我们匹配的核心依据；
2. 遍历目标程序集的所有类型定义，筛选出符合要求的类：有命名空间、公共访问权限、非抽象、非接口的具体类；
3. 对每个符合条件的类，遍历它实现的所有接口，将接口的完整名称和目标接口的完整名称对比，匹配成功就记录这个类。

完整实现代码 #

首先我们可以定义一个简单的类来存储找到的实现类信息：

public class ImplementedClassInfo
{
    public string Namespace { get; set; }
    public string Name { get; set; }
    public string FullName => $"{Namespace}.{Name}";
}

然后实现泛型检查方法：

using System.Collections.Generic;
using System.IO;
using System.Reflection.Metadata;
using System.Reflection.PortableExecutable;
using System.Linq;

public static class ReflectionHelper
{
    public static ICollection<ImplementedClassInfo> HasInterface<T>(string assemblyPath)
    {
        var implementedClasses = new List<ImplementedClassInfo>();
        // 获取目标接口的标准完整名称，这是匹配的关键
        var targetInterfaceFullName = typeof(T).FullName;
        
        // 如果接口没有完整名称（比如动态生成的类型），直接返回空集合
        if (string.IsNullOrEmpty(targetInterfaceFullName))
        {
            return implementedClasses;
        }

        using var streamReader = new StreamReader(assemblyPath);
        using var peReader = new PEReader(streamReader.BaseStream);
        var metadataReader = peReader.GetMetadataReader();

        foreach (var typeDefHandle in metadataReader.TypeDefinitions)
        {
            var typeDef = metadataReader.GetTypeDefinition(typeDefHandle);
            var typeNamespace = metadataReader.GetString(typeDef.Namespace);

            // 跳过没有命名空间的类型（通常是系统生成的类型）
            if (string.IsNullOrEmpty(typeNamespace))
                continue;

            // 只保留公共、非抽象、非接口的具体类
            if (typeDef.Attributes.HasFlag(TypeAttributes.Interface) || 
                typeDef.Attributes.HasFlag(TypeAttributes.Abstract) || 
                !typeDef.Attributes.HasFlag(TypeAttributes.Public))
                continue;

            var typeName = metadataReader.GetString(typeDef.Name);
            bool doesImplementTarget = false;

            // 遍历当前类实现的所有接口
            foreach (var interfaceImplHandle in typeDef.GetInterfaceImplementations())
            {
                var interfaceImpl = metadataReader.GetInterfaceImplementation(interfaceImplHandle);
                var interfaceHandle = interfaceImpl.Interface;
                string interfaceFullName = null;

                // 接口可能是当前程序集的定义（TypeDefinition），或者引用外部程序集的类型（TypeReference）
                if (interfaceHandle.IsTypeDefinition)
                {
                    var interfaceDef = metadataReader.GetTypeDefinition((TypeDefinitionHandle)interfaceHandle);
                    interfaceFullName = $"{metadataReader.GetString(interfaceDef.Namespace)}.{metadataReader.GetString(interfaceDef.Name)}";
                }
                else if (interfaceHandle.IsTypeReference)
                {
                    var interfaceRef = metadataReader.GetTypeReference((TypeReferenceHandle)interfaceHandle);
                    interfaceFullName = $"{metadataReader.GetString(interfaceRef.Namespace)}.{metadataReader.GetString(interfaceRef.Name)}";
                }

                // 如果匹配到目标接口，标记当前类符合要求并跳出循环
                if (interfaceFullName == targetInterfaceFullName)
                {
                    doesImplementTarget = true;
                    break;
                }
            }

            if (doesImplementTarget)
            {
                implementedClasses.Add(new ImplementedClassInfo
                {
                    Namespace = typeNamespace,
                    Name = typeName
                });
            }
        }

        return implementedClasses;
    }
}

关键细节说明 #

• 为什么用typeof(T).FullName而不是手动拼接？
  FullName是.NET提供的标准类型完整名称，比手动拼接Namespace + "." + Name更可靠，尤其是处理泛型类型时，FullName会包含泛型参数的标识（比如System.Collections.Generic.IList1`），能准确匹配Metadata里的泛型接口定义。
• 区分TypeDefinition和TypeReference
  你的目标接口在Base程序集里，所以在被检查的程序集中，这个接口是一个TypeReference（引用外部类型）；如果接口是当前程序集定义的，那就是TypeDefinition。代码里做了兼容处理，保证两种情况都能正确匹配。
• 严格的类型筛选
  完全按照你的需求筛选：跳过无命名空间的类型，只保留公共、非抽象、非接口的具体类，确保返回的都是符合要求的“有效”类。

使用示例 #

// 检查指定程序集是否包含实现IMyInterface的类
var validClasses = ReflectionHelper.HasInterface<IMyInterface>("C:\\YourFolder\\TargetAssembly.dll");

if (validClasses.Any())
{
    Console.WriteLine("找到符合要求的实现类：");
    foreach (var cls in validClasses)
    {
        Console.WriteLine(cls.FullName);
    }
    // 在这里加载这些合法的程序集即可
}
else
{
    Console.WriteLine("未找到符合要求的实现类");
}

注意事项 #

如果你的目标接口是泛型接口，比如IMyInterface<T>，需要注意typeof(IMyInterface<>).FullName的格式（不同.NET版本可能略有差异），Metadata里的接口名称会和这个格式一致，所以代码不需要额外修改就能匹配。

内容来源于stack exchange