能否通过System.Reflection.Emit逐条执行动态方法中的IL指令？

无法通过CLR默认的方法调用实现IL指令逐条执行，需要借助以下两种方式实现：

方案一：利用.NET调试API实现IL单步执行 #

借助ICorDebug系列接口（.NET调试框架核心组件），可以附加到当前进程，定位到动态生成的方法，设置IL指令级断点，通过调试器的单步执行功能逐条运行指令，同时获取栈帧、局部变量、操作栈的实时状态。
核心步骤：

• 初始化调试器并附加到当前进程；
• 定位到动态生成的Foo.Bar方法；
• 在每个IL指令位置设置断点；
• 触发方法执行，每次断点命中时读取当前状态，再继续执行下一条指令；
  注意：该方式需要熟悉.NET调试API的使用，代码复杂度较高，且调试器附加会影响进程运行状态。

方案二：自定义IL解释器逐条执行 #

手动解析IL指令流，模拟CLR的执行逻辑，维护自己的操作栈、局部变量表，逐条执行指令并保存状态。这种方式完全可控，无需依赖调试环境。

简化示例代码 #

针对你提供的动态方法，以下是一个简化的IL解释器实现：

var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new("_"), AssemblyBuilderAccess.Run);
var module = assemblyBuilder.DefineDynamicModule("_._");
var type = module.DefineType("Foo");
var method = type.DefineMethod(
    name: "Bar",
    attributes: MethodAttributes.Public | MethodAttributes.Static,
    returnType: typeof(string),
    parameterTypes: null
);
var ilGen = method.GetILGenerator();
ilGen.DeclareLocal(typeof(string));

ilGen.Emit(OpCodes.Ldstr, "Hello, World!");
ilGen.Emit(OpCodes.Stloc_0);
ilGen.Emit(OpCodes.Ldloc_0);
ilGen.Emit(OpCodes.Dup);
ilGen.EmitCall(
    OpCodes.Call,
    typeof(Console).GetMethod("WriteLine", new[] { typeof(string) })!,
    null
);
ilGen.Emit(OpCodes.Ret);

var nonDynamicType = type.CreateType();
var createdMethod = nonDynamicType!.GetMethod("Bar")!;

// 自定义IL解释器部分
var ilBytes = createdMethod.GetMethodBody()!.GetILAsByteArray();
var reader = new BinaryReader(new MemoryStream(ilBytes));

var stack = new Stack<object>();
var locals = new object[1]; // 对应声明的1个string局部变量

while (reader.BaseStream.Position < ilBytes.Length)
{
    OpCode opCode = OpCodes.GetOpCode(reader.ReadByte());
    switch (opCode.Name)
    {
        case "ldstr":
            int strToken = reader.ReadInt32();
            string strValue = (string)createdMethod.Module.ResolveString(strToken);
            stack.Push(strValue);
            Console.WriteLine($"执行指令: {opCode.Name} | 栈顶元素: {strValue}");
            break;
        case "stloc.0":
            locals[0] = stack.Pop();
            Console.WriteLine($"执行指令: {opCode.Name} | 局部变量0赋值为: {locals[0]}");
            break;
        case "ldloc.0":
            stack.Push(locals[0]);
            Console.WriteLine($"执行指令: {opCode.Name} | 栈顶元素: {locals[0]}");
            break;
        case "dup":
            stack.Push(stack.Peek());
            Console.WriteLine($"执行指令: {opCode.Name} | 栈顶元素: {stack.Peek()}");
            break;
        case "call":
            int methodToken = reader.ReadInt32();
            MethodInfo targetMethod = (MethodInfo)createdMethod.Module.ResolveMethod(methodToken);
            object[] args = new object[targetMethod.GetParameters().Length];
            for (int i = args.Length - 1; i >= 0; i--)
            {
                args[i] = stack.Pop();
            }
            targetMethod.Invoke(null, args);
            Console.WriteLine($"执行指令: {opCode.Name} | 已调用方法: {targetMethod.Name}");
            break;
        case "ret":
            object result = stack.Pop();
            Console.WriteLine($"执行指令: {opCode.Name} | 返回值: {result}");
            goto endExecution;
        default:
            throw new NotImplementedException($"未处理IL指令: {opCode.Name}");
    }
}
endExecution:

说明 #

自定义解释器需要针对所有用到的IL操作码编写处理逻辑，对于分支、异常处理、值类型操作等复杂场景，需要完善更多细节，但完全可以实现逐条执行并保留状态的需求。

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