这个问题问得很到位——区分程序集的引用和实际使用确实是反射里的一个常见坑：单纯用System.Reflection只能看到元数据里的引用记录（只要程序集加了库的引用，不管用没用到都会存在），没法知道代码到底有没有真的实例化、调用或访问目标类型。

要解决这个问题，核心是分析程序集的IL代码：只有当代码实际使用了某个类型时，IL指令里才会出现对该类型（或其成员）的引用。下面是两种可行方案：

方法一：用Mono.Cecil分析IL（推荐） #

Mono.Cecil是一个专门用来读取、修改.NET程序集的库，它能轻松解析IL指令，帮你找到对目标类型的实际引用。步骤如下：

1. 安装Mono.Cecil #

通过NuGet包管理器安装Mono.Cecil，或者用命令行：

Install-Package Mono.Cecil

2. 编写检测代码 #

下面的方法可以检查目标程序集是否实际使用了指定类型：

using Mono.Cecil;
using System;
using System.Linq;

public static class TypeUsageChecker
{
    public static bool IsTypeActuallyUsed(string targetAssemblyPath, Type targetLibraryType)
    {
        // 加载需要检测的程序集（就是引用了库的那个程序集）
        using var assemblyDef = AssemblyDefinition.ReadAssembly(targetAssemblyPath);
        
        // 获取库程序集的名称和目标类型的全名
        var libraryAssemblyName = targetLibraryType.Assembly.GetName().Name;
        var targetTypeFullName = targetLibraryType.FullName;

        // 遍历程序集里的所有模块、类型、方法
        foreach (var module in assemblyDef.Modules)
        {
            foreach (var type in module.Types)
            {
                foreach (var method in type.Methods)
                {
                    // 跳过没有IL体的方法（比如抽象方法）
                    if (!method.HasBody) continue;

                    // 遍历方法的每一条IL指令
                    foreach (var instruction in method.Body.Instructions)
                    {
                        // 检查指令操作数是否是类型引用
                        if (instruction.Operand is TypeReference typeRef)
                        {
                            if (MatchesTargetType(typeRef, libraryAssemblyName, targetTypeFullName))
                                return true;
                        }
                        // 检查是否是方法引用（比如调用目标类型的构造函数或方法）
                        else if (instruction.Operand is MethodReference methodRef)
                        {
                            if (MatchesTargetType(methodRef.DeclaringType, libraryAssemblyName, targetTypeFullName))
                                return true;
                        }
                        // 检查是否是字段引用（比如访问目标类型的静态字段）
                        else if (instruction.Operand is FieldReference fieldRef)
                        {
                            if (MatchesTargetType(fieldRef.DeclaringType, libraryAssemblyName, targetTypeFullName))
                                return true;
                        }
                    }
                }
            }
        }

        return false;
    }

    private static bool MatchesTargetType(TypeReference typeRef, string libraryAssemblyName, string targetTypeFullName)
    {
        // 匹配程序集名称和类型全名（如果是强命名程序集，可能还要匹配版本、公钥等）
        return typeRef.Scope.Name == libraryAssemblyName && typeRef.FullName == targetTypeFullName;
    }
}

3. 使用示例 #

针对你的场景，比如要检测MyApp.exe是否使用了LibraryClass1：

var targetType = typeof(LibraryClass1);
bool isUsed = TypeUsageChecker.IsTypeActuallyUsed(@"C:\path\to\MyApp.exe", targetType);
Console.WriteLine(isUsed ? "LibraryClass1被实际使用了" : "LibraryClass1未被使用");

这个方法能检测到所有实际使用场景：比如new LibraryClass1()、调用其方法、访问其字段、甚至作为泛型参数使用等。

方法二：手动解析PE文件（不推荐） #

如果不想用第三方库，你可以手动解析程序集的PE格式，读取元数据表和IL代码。但这个过程非常繁琐，需要了解.NET程序集的底层结构（比如元数据表中的TypeRef、MethodRef表，以及IL指令的编码规则），一般不推荐，除非你有特殊需求。

关键注意事项 #

• 泛型类型处理：如果目标类型是泛型（比如List<LibraryClass1>），需要调整类型全名的匹配逻辑，因为Cecil里的泛型类型全名格式是Namespace.Type1[[Namespace.GenericArg, Assembly]]`。
• 嵌套类型：嵌套类型的全名格式是OuterType+InnerType，要确保匹配正确。
• 强命名程序集：如果你的库是强命名的，可能需要在匹配时加入版本、公钥令牌等信息，避免误判同名的不同版本类型。

内容的提问来源于stack exchange，提问作者Austin Salgat