MSIL 入门文档

MSIL（Microsoft Intermediate Language 简称：IL），.Net 框架使用的中间件语言。在实际开发中使用到il的机会并不会特别多，在开发一些需要反射才能做到时的功能却效果很好。

IL命令的说明请参考：https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes?view=netcore-3.1

工具说明

1. 反汇编程序(Ildasm.exe）,这是一个安装visual studio后都有的一个程序。在vs开发者控制台中执行即可。

2. 编译工具（ilasm.exe),这是将il文件编译的程序。

   示例：ilasm /exe test.il /output:test.exe

   具体使用参考：https://docs.microsoft.com/zh-cn/dotnet/framework/tools/ilasm-exe-il-assembler

3. 还有包括ILSpy，dnSpy 等反编译工具

简单动态代码示例

  public class Demo
  {
      public string Name{get;set;}
  }

  int Clone(Demo str){
    int t;
    Demo d=str;
    Console.WriteLine(d.Name);
    t=100+5;
    t=2*8*t;
    Console.WriteLine(t);
    return t;
  }

上下两个示例：上文是下文使用IL的实现方法。

            var dynamicMethod = new DynamicMethod("Clone", typeof(int), new[] { typeof(Demo) });// build a name is "Clone"  of method and return is Int with parameter is a "Demo" type
            var il = dynamicMethod.GetILGenerator();//创建il的执行
            var t = il.DeclareLocal(typeof(int));//声明方法内的一个int类型的变量
            var v= typeof(Demo).GetProperty("Name").GetGetMethod();
            var d = il.DeclareLocal(typeof(Demo));
            var info = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) });//回调方法
            var name = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) });//回调方法

            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Stloc, t);
            il.Emit(OpCodes.Ldloc, t);
            il.Emit(OpCodes.Call, v);
            il.Emit(OpCodes.Call,name);

            il.Emit(OpCodes.Ldc_I4, 100);//往栈中写入4个字节的数据100 
            il.Emit(OpCodes.Ldc_I4, 5);
            il.Emit(OpCodes.Add);//执行相加
            il.Emit(OpCodes.Stloc, t);//从栈中取出值,赋值给变量
            il.Emit(OpCodes.Ldc_I4, 2);// write a variable to the statck
            il.Emit(OpCodes.Ldc_I4, 8);
            il.Emit(OpCodes.Mul);// 乘法操作
            il.Emit(OpCodes.Ldloc, t);
            il.Emit(OpCodes.Mul);
            il.Emit(OpCodes.Stloc, t);
            il.Emit(OpCodes.Ldloc, t);
            il.Emit(OpCodes.Call, info);//执行方法
            il.Emit(OpCodes.Ldloc, t);//write the variable to the stack
            il.Emit(OpCodes.Ret);//return the value
            var action = (Func<Demo, int>)dynamicMethod.CreateDelegate(typeof(Func<Demo, int>));//创建委托指针
            Console.WriteLine(action(new Demo
                {
                    Name="瑞维尼"
                }));//running the dynamic method 

il.Emit(OpCodes.Stloc, t) 注意第一次使用这条命令是将参数返回给变量，这里本来应该是一个Demo类型的数据，但是用int类型的变量接收了，这时候int的值其实保存了内存地址。正常应该是错误的，这里确可以。

IL代码主要区别在内存中所以，画了一张图来表示内存的改变。每一行指令都会格一行，需要参照上图的示例，尤其注意内存的中stack的变化。

栈的规则先进后出，每次计算都会从栈中取出相应的值加入计算，有汇编基础的都应该知道内存中函数的内存运算方式。

示例输出结果：

瑞维尼
1680
1680

编写简单MSIL程序

using System;
namespace test{
    public class Program{
        private static void Main(string[] args){
            int a=1;
            int b=5;
            Console.WriteLine(a*b*3+2);
        }
    }
}

执行命令csc test.cs 生成 test.exe 结果为：17

IL 代码

需要注意il调用方法时，参数从评价堆栈中取出，如果方法不是静态方法，this也要从评价堆栈中取出，为第一参数（也就是第一压入栈中）

.assembly extern mscorlib {auto}
.assembly Test{}
.module Test.exe
.namespace Test
{
    .class public Program extends [mscorlib]System.Object
    {
        .method static private void Main(string [] args)
        {
            .entrypoint //主函数
            .maxstack //评价堆栈的最大深度
            .locals init(int32 V_0,int32 V_1,int32& pl) //定义变量
            nop //什么都不做
            ldc.i4.1 // 往栈中存入常量1，常量大小4个byte
            stloc.0 // 从栈中取出值给变量0
            ldloc.0 // 将变量0写入栈中
            ldc.i4.5 //往栈中存入1
            stloc.1 //  从栈中取出值给变量1
            ldloc.1 // 将变量1写入栈中
            mul //从栈中取出两个值进行乘法运算
            ldc.i4.3 //将常量3写入评价堆栈
            mul 
            ldc.i4.2
            add
            call void[mscorlib]System.Console::WriteLine(int32) //调用方法
            nop
            ret 
        }
    }
}

运行命令： ilasm /output=test.exe /exe 对il文件进行编译。结果为：17

使用 IL 新建对象

using System;

namespace Test{
    public class Program{
        string Name;
        public Program(string name)
        {
            this.Name=name;
            Console.WriteLine(this.Name);
        }
        
        public string Show()
        {
            return this.Name;
        }

       public static void Main(string[] args)
        {
            Program t=new Program("this is a test");
            Console.WriteLine(t.Show());
        }
    }
}

对应的IL代码

.assembly extern mscorlib {auto}
.assembly Test{}
.module Test.exe
.namespace Test
{
    .class public Program extends [mscorlib]System.Object
    {
        .method static private void Main(string [] args)
        {
            .entrypoint
            .maxstack 1
            .locals init(class Test.Program t)// Program t
            nop
            ldstr "this is a test" //将 字符串写入栈中
            newobj instance void Test.Program::.ctor(string) //初始化一个类
            stloc t// 赋值给变量t
            ldloc t //取出值到stack
            callvirt instance string Test.Program::show() //执行show方法
            call void[mscorlib]System.Console::WriteLine(string) //输入返回值
            ret 
        }

        .field private string Name //定义私有字段Name

        .method public hidebysig specialname  
        rtspecialname 
        instance void  .ctor(string) //定义构造函数
        {
              .maxstack  8
              ldarg.0//加载第一个参数this
              call  instance void [mscorlib]System.Object::.ctor() //初始化object
              ldarg.0 //加载第一个参数 this
              ldarg.1//加载传入的参数 name 到stack 
              stfld string Test.Program::Name //把stack 值写入到Name
              ldarg.0 //加载this
              ldfld string Test.Program::Name //取出字段Name的值到stack
              call void[mscorlib]System.Console::WriteLine(string) //输出值
              nop
              ret
        }

        .method public hidebysig specialname 
        rtspecialname 
        instance void  .ctor()
        {
              .maxstack  8
              ldarg.0
              call  instance void [mscorlib]System.Object::.ctor()
              nop
              ret
        }
        .method public hidebysig instance string show()
        {
            ldarg.0
            ldfld string Test.Program::Name
            ret
        }
    }
}

流程控制

       public static void Main(string[] args)
        {
            // Program t=new Program("this is a test");

            for(int i=0;i<=10;i++){
                if(i>9){
                    Console.WriteLine(i);
                    Console.WriteLine("i>9");
                }else if(i>5){
                    Console.WriteLine(i);
                    Console.WriteLine("i>5");
                }else{
                    Console.WriteLine(i);
                    Console.WriteLine("deault value");
                }
            }
            int t=0;
            while(t>0){
                switch(t){
                    case 0:Console.WriteLine("current value is 0");break;
                    case 1:Console.WriteLine("Current values is 1");break;
                    default: Console.WriteLine(t);break;
                }
                t++;
                if(t>3)break;
            }

        }

对应的IL代码

.assembly extern mscorlib {auto}
.assembly Test{}
.module Test.exe
.namespace Test
{
    .class public Program extends [mscorlib]System.Object
    {
        .method static private void Main(string [] args)
        {
                .entrypoint
                // 代码大小       194 (0xc2)
                .maxstack  2
                .locals init (int32 V_0,
                        int32 V_1,
                        bool V_2,
                        bool V_3,
                        bool V_4,
                        int32 V_5,
                        int32 V_6,
                        bool V_7,
                        bool V_8)
                  nop
                  ldc.i4.0
                  stloc.1 // 将0 写入第2个变量
                  br.s       IL_005c //跳转到指定的IL偏移地址，如果偏移值比较小勇br.s 减少il代码大小（br也可以）
                IL_0005:  nop
                  ldloc.1 // 取出第2个变量
                  ldc.i4.s   9 //写入9
                  cgt //比较两个值。如果第一个值大于第二个值，则将整数值 1 (int32) 推送到计算堆栈上；反之，将 0 (int32) 推送到计算堆栈上。
                  stloc.2 //赋值给第3个变量
                  ldloc.2 //取出第3个变量
                  brfalse.s  IL_0025 // 如果第3个变量是0跳转到偏移值25

                  //这一输出i>9的数据
                    nop 
                    ldloc.1
                    call       void [mscorlib]System.Console::WriteLine(int32)
                    nop
                    ldstr      "i>9"
                    call       void [mscorlib]System.Console::WriteLine(string)
                    nop
                    nop
                    br.s       IL_0057 //本次循环中的一环执行完成，跳到指定偏移值，对V_1进行递增

                IL_0025:  ldloc.1 //如果上轮第3个变量为0，跳转的目标地址，写入第2变量也就是i变量
                  ldc.i4.5 //写入5
                  cgt
                  stloc.3
                  ldloc.3
                  brfalse.s  IL_0043 //如果第4个变量为0，跳转到偏移地
                  nop
                  ldloc.1
                  call       void [mscorlib]System.Console::WriteLine(int32)
                  nop
                  ldstr      "i>5"
                  call       void [mscorlib]System.Console::WriteLine(string)
                  nop
                  nop
                  br.s       IL_0057
                IL_0043:  nop //跳转过来的值
                  ldloc.1
                  call       void [mscorlib]System.Console::WriteLine(int32)
                  nop
                  ldstr      "i>5"
                  call       void [mscorlib]System.Console::WriteLine(string)
                  nop
                  nop
                IL_0057:  nop //执行完，对第2个变量进行加1
                  ldloc.1
                  ldc.i4.1
                  add
                  stloc.1
                IL_005c:  ldloc.1 //添加完成后的判断
                  ldc.i4.s   10
                  cgt
                  ldc.i4.0
                  ceq
                  stloc.s    V_4
                  ldloc.s    V_4
                  brtrue.s   IL_0005 //如果满足，跳到指定偏移
                  ldc.i4.0
                  stloc.0
                  br.s       IL_00b7 //不满足跳出
                IL_006e:  nop
                  ldloc.0 //将第一个变量写入stack中，case 值为0
                  stloc.s    V_6 //取出
                  ldloc.s    V_6
                  stloc.s    V_5
                  ldloc.s    V_5
                  brfalse.s  IL_0083//两值不同跳转
                  br.s       IL_007c //无理由跳转
                IL_007c:  ldloc.s    V_5 
                  ldc.i4.1  //case值为1
                  beq.s      IL_0090 //不等于跳转
                  br.s       IL_009d //反正无条件跳转
                IL_0083:  ldstr      "current value is 0"
                  call       void [mscorlib]System.Console::WriteLine(string)
                  nop
                  br.s       IL_00a6
                IL_0090:  ldstr      "Current values is 1"
                  call       void [mscorlib]System.Console::WriteLine(string)
                  nop
                  br.s       IL_00a6
                IL_009d:  ldloc.0
                  call       void [mscorlib]System.Console::WriteLine(int32)
                  nop
                  br.s       IL_00a6
                IL_00a6:  ldloc.0
                  ldc.i4.1
                  add //执行i++操作
                  stloc.0
                  ldloc.0 
                  ldc.i4.3
                  cgt //比较
                  stloc.s    V_7
                  ldloc.s    V_7
                  brfalse.s  IL_00b6 //不满足，进入
                  br.s       IL_00c1 //满足，跳出
                IL_00b6:  nop
                IL_00b7:  ldloc.0
                  ldc.i4.0
                  cgt
                  stloc.s    V_8
                  ldloc.s    V_8
                  brtrue.s   IL_006e
                IL_00c1:  ret
        }
    }
}

命令列表

MSIL 入门

原文：https://www.cnblogs.com/panyan/p/12830222.html