Emit 辅助类

  由于动态编译是基于 Emit 的，因此在定义构造函数、方法和属性时，都要使用到 IL（中间语言），在 DynamicMethod 实例或上下文 Context 中可以使用 EmitHelper 对象来编织 IL 代码。它是对 ILGenerator 类的全部操作的包装，以达到在使用 IL 指令时更加方便，具体的方法请参考 OpCodes 类的常量定义。为了保持与 IL 指令一致，EmitHelper 类的方法使用小写命名。

1、IL指令包装

  与指令相关的方法或属性如下（举例）：

• add 属性：将两个值相加并将结果推送到计算堆栈上。

• add_ovf 属性：将两个整数相加，执行溢出检查，并且将结果推送到计算堆栈上。

• add_ovf_un 属性：将两个无符号整数值相加，执行溢出检查，并且将结果推送到计算堆栈上。

• and 属性：计算两个值的按位“与”并将结果推送到计算堆栈上。

• beq_s 方法：如果两个值相等，则将控制转移到目标指令（短格式）。

• ldarg_0 属性：将索引为 0 的参数加载到计算堆栈上。

• ldc_i4_ 方法：将指定的整数作为 int32 推送到计算堆栈上。

• ldloc 方法：将指定索引处的局部变量加载到计算堆栈上。

• callvirt 方法：对对象调用后期绑定方法，并且将返回值推送到计算堆栈上。

• unbox 方法：将值类型的已装箱的表示形式转换为其未装箱的形式。

  。。。。。。

  最后表一列出了所有 IL 指令对应的方法或属性。

2、辅助方法

• ldarg 方法

  将索引处的参数加载到堆栈上。IL 指令最多支持 ldarg_1、ldarg_2、ldarg_3，和 ldarg_s 方法，但使用起来不太简便，因此 ldarg(int index) 方法为他们提供了统一的调用。

• end 方法

  方法本身没有具体的意义，仅在 EmitHelper 对象在使用了属性之后，再使用 end 方法以表结束。

3、其他方法

• Assert 方法

  Assert 方法判断一个断言是否成立，如果成立则进行相应的链式编织。如下所示：

[TestMethod]
public void TestEmitAssert()
{
    var callMethod = true; //用于模拟断言
    var builder = new DynamicMethod("TestHello", typeof(bool), null);
    var emiter = new EmitHelper(method.GetILGenerator())
        .Assert(callMethod,
            e => e.ldstr("fireasy")
                .call(typeof(Helper).GetMethod("GetHello", new[] { typeof(string) })),
            e => e.ldstr("hello fireasy"))
        .call(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }))
        .ldc_i4_1.ret();

    var func = builder.CreateDelegate(typeof(Func<bool>));

    Assert.IsTrue((bool)func.DynamicInvoke(null));
}

public class Helper
{
    public static string GetHello(string name)
    {
        return "hello " + name;
    }
}

//------方法原型--------
public static bool TestHello()
{
    Console.WriteLine(Helper.GetHello("fireasy"));
    return true;
}
//----------------------

• Each 方法

  Each 方法用于遍列一个序列，将序列中的元素编辑到 EmitHelper 对象里。如下所示：

[TestMethod]
public void TestEmitEach()
{
    var cities = new[] { "kunming", "chengdu", "guangzhou" };
    var builder = new DynamicMethod("TestItems", typeof(int), new[] { typeof(List<string>) });
    var emiter = new EmitHelper(method.GetILGenerator())
        .Each(cities, (e, str, i) =>
            {
                e.ldarg_0.ldstr(str)
                  .callvirt(typeof(List<string>).GetMethod("Add"));
            })
        .ldarg_0.callvirt(typeof(List<string>).GetMethod("get_Count")).ret();

    var items = new List<string>();
    var func = builder.CreateDelegate(typeof(Func<List<string>, int>));

    Assert.AreEqual(3, (int)func.DynamicInvoke(items));
}

//------方法原型--------
public static int TestItems(List<string> items)
{
    items.Add("kunming");
    items.Add("chengdu");
    items.Add("guangzhou");
    return items.Count;
}
//----------------------

• For 方法

  For 方法用于循环一组数字，一般用在循环体内有共性的指令之时，如下所示：

[TestMethod]
public void TestEmitFor()
{
    var method = new DynamicMethod("TestWrite", typeof(void), 
        new[] { typeof(string), typeof(string), typeof(int) });

    var parameters = method.GetParameters();
    var emiter = new EmitHelper(method.GetILGenerator())
        .ldc_i4(parameters.Length)
        .newarr(typeof(object))
        .For(0, parameters.Length, (e, i) =>
            {
                e.dup.ldc_i4(i).ldarg(i)
                    .Assert(parameters[i].ParameterType.IsValueType, 
                      e1 => e1.box(parameters[i].ParameterType))
                    .stelem_ref.end();
            })
        .call(typeof(string).GetMethod("Concat", new[] { typeof(object[]) }))
        .call(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }))
        .ret();

    var action = method.CreateDelegate(typeof(Action<string, string, int>));
    action.DynamicInvoke("fireasy", "kunming", 33);
}

//------方法原型--------
public static void TestWrite(string name, string city, int age)
{
    Console.WriteLine(string.Concat(new object[] { name, city, age }));
}
//----------------------

4、表一：IL指令与方法/属性对应表