如何通过反射获取子类调用基类构造函数的硬编码参数

这问题挺典型的——那些传给base的硬编码格式化字符串，常规反射根本拿不到，因为它们不会存在子类的元数据里。得从源代码或者编译后的IL入手，给你两种实用方案：

如果你能拿到项目的源代码，用Roslyn（.NET Compiler Platform）做静态分析是最直接的，能精准定位到子类构造函数里的base(...)调用，提取第一个字符串参数。

举个可运行的代码示例，假设你要分析某个目录下的源代码：

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class FormatStringExtractor
{
    static void Main(string[] args)
    {
        // 替换成你的源代码目录或单个cs文件路径
        var sourcePath = @"C:\YourProject\MessageClasses";
        var files = Directory.EnumerateFiles(sourcePath, "*.cs", SearchOption.AllDirectories);

        var syntaxTrees = files.Select(file => CSharpSyntaxTree.ParseText(File.ReadAllText(file)));
        var compilation = CSharpCompilation.Create("TempCompilation")
            .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
            .AddSyntaxTrees(syntaxTrees);

        // 找到BaseMessage类型（注意替换成你的实际命名空间）
        var baseMessageType = compilation.GetTypeByMetadataName("YourNamespace.BaseMessage");
        if (baseMessageType == null)
        {
            Console.WriteLine("未找到BaseMessage类型");
            return;
        }

        // 筛选所有继承自BaseMessage的子类
        var messageSubclasses = compilation.GetSymbolsWithName(s => true, SymbolFilter.Type)
            .OfType<INamedTypeSymbol>()
            .Where(t => t.BaseType?.Equals(baseMessageType, SymbolEqualityComparer.Default) == true);

        foreach (var subclass in messageSubclasses)
        {
            // 获取子类的实例构造函数
            var ctor = subclass.Constructors.FirstOrDefault(c => !c.IsStatic && c.DeclaringType.Equals(subclass));
            if (ctor == null) continue;

            // 定位构造函数的语法节点，检查base初始化器
            var ctorSyntax = ctor.DeclaringSyntaxReferences.First().GetSyntax() as ConstructorDeclarationSyntax;
            if (ctorSyntax?.Initializer == null || ctorSyntax.Initializer.Kind() != SyntaxKind.BaseConstructorInitializer) continue;

            // 提取base调用的第一个字符串字面量
            var firstArg = ctorSyntax.Initializer.ArgumentList.Arguments.FirstOrDefault();
            if (firstArg?.Expression is LiteralExpressionSyntax literal && literal.Kind() == SyntaxKind.StringLiteralExpression)
            {
                Console.WriteLine($"{subclass.Name}: {literal.Token.ValueText}");
            }
        }
    }
}

关键逻辑说明： #

• 用Roslyn解析源代码生成语法树，构建编译上下文
• 精准筛选所有继承自BaseMessage的类型
• 检查每个子类构造函数的base初始化器，直接提取硬编码的字符串参数

如果只有编译好的程序集（.dll/.exe），可以通过解析IL指令来提取这些字符串——编译时，硬编码字符串会被打包成ldstr指令的操作数，子类构造函数调用base前一定会先加载这个参数。

这里用Mono.Cecil简化IL解析（原生API处理OpCode太繁琐），先安装NuGet包：Install-Package Mono.Cecil

代码示例：

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

class CompiledAssemblyExtractor
{
    static void Main(string[] args)
    {
        // 替换成你的程序集路径
        var assemblyPath = @"C:\YourProject\bin\Debug\net6.0\YourAssembly.dll";
        var assembly = AssemblyDefinition.ReadAssembly(assemblyPath);

        // 找到BaseMessage类型（注意替换成实际命名空间）
        var baseMessageType = assembly.MainModule.Types.First(t => t.FullName == "YourNamespace.BaseMessage");
        if (baseMessageType == null)
        {
            Console.WriteLine("未找到BaseMessage类型");
            return;
        }

        // 筛选所有直接继承自BaseMessage的子类
        var messageSubclasses = assembly.MainModule.Types
            .Where(t => t.BaseType?.FullName == baseMessageType.FullName && !t.IsAbstract);

        foreach (var subclass in messageSubclasses)
        {
            // 获取子类的实例构造函数
            var ctor = subclass.Methods.FirstOrDefault(m => m.IsConstructor && !m.IsStatic);
            if (ctor == null) continue;

            // 找到第一个ldstr指令（对应传给base的格式化字符串）
            var ldstrInstruction = ctor.Body.Instructions.FirstOrDefault(i => i.OpCode == Mono.Cecil.Cil.OpCodes.Ldstr);
            if (ldstrInstruction != null && ldstrInstruction.Operand is string formatString)
            {
                Console.WriteLine($"{subclass.Name}: {formatString}");
            }
        }
    }
}

关键逻辑说明： #

• 用Mono.Cecil加载目标程序集
• 筛选继承自BaseMessage的子类
• 解析构造函数IL，提取第一个ldstr指令的操作数——也就是你要的硬编码格式化字符串

注意：如果子类构造函数在调用base前有其他ldstr指令，需要进一步分析IL的调用流程（比如找到调用base构造函数的call指令，往前追溯对应的字符串参数），但你的示例代码结构简单，这个方法完全适用。

内容的提问来源于stack exchange，提问作者Roy Cheung