In the preceding C# code, I’m creating a dynamic method and adding a few IL instructions to it, and then invoking the dynamic method:

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); // string str1 = "Hello, World!";
        ilGen.Emit(OpCodes.Dup); // string str2 = "Hello, World!";
        ilGen.EmitCall(
            OpCodes.Call,
            typeof(Console).GetMethod("WriteLine", types: new[] { typeof(string) })!,
            optionalParameterTypes: null
        ); // Console.WriteLine(str1);
        ilGen.Emit(OpCodes.Ret); // return str2;

        var nonDynamicType = type.CreateType();
        var createdMethod = nonDynamicType!.GetMethod("Bar")!;
        object? result = createdMethod.Invoke(null, null);
        Console.WriteLine($"Method returned {result}");

It works fine – as expected, I see the following in the console:

Hello, World!
Method returned Hello, World!

Now, I would like to execute IL instructions one-by-one. With the approach above, I execute all IL instructions at once; is it possible to execute only one instruction, and then (perhaps later) manually execute another in the same dynamic method while keeping all local variables and the stack/heap same (and then only return from method once the ret IL instruction is executed)?