利用DynamicILInfo类动态生成方法

　　ILGenerator与DynamicILInfo类是不同的。它直接使用字节数组设置IL代码,异常和本地的签名。那么,我们怎样才能获得这些字节数组从ILGenerator 与DynamicILInfo类是不同的。它直接使用字节数组设置IL代码,异常和本地的签名。那么,我们怎样才能获得这些字节数组，请看下面的代码:

using System;
using System.Reflection;
using System.Reflection.Emit;

class Demo
{
    static void Main()
    {
        DynamicMethod dm = new DynamicMethod("HelloWorld", typeof(void), Type.EmptyTypes, typeof(Demo), false);
        DynamicILInfo il = dm.GetDynamicILInfo();

        SignatureHelper sigHelper = SignatureHelper.GetLocalVarSigHelper();
        il.SetLocalSignature(sigHelper.GetSignature());

        byte[] code = { 0x00, 0x72, 0x01, 0x00, 0x00, 0x70, 0x28, 0x04, 0x00, 0x00, 0x0a, 0x00, 0x2a };
        int token0 = il.GetTokenFor("Hello world");
        int token1 = il.GetTokenFor(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }).MethodHandle);
        PutInteger4(token0, 0x0002, code);
        PutInteger4(token1, 0x0007, code);
        il.SetCode(code, 8);

        dm.Invoke(null, null);　　     Console.Read();
    }

    static void PutInteger4(int value, int startPos, byte[] array)
    {
        array[startPos++] = (byte)value;
        array[startPos++] = (byte)(value >> 8);
        array[startPos++] = (byte)(value >> 16);
        array[startPos++] = (byte)(value >> 24);
    }
}

以下是Microsoft enginee 的解释：

If the dynamic method we are going to create is based on a static method in some existing assembly, we can view the IL code (bytes) of the static method via ildasm or by using MethodBody.GetILByteArray. We can then build the byte array for SetCode from there. For all tokens used in the original static method, be sure to replace them (bold, as shown above and below in this example) with those generated from GetTokenFor.

.method public hidebysig static void HelloWorld() cil managed
// SIG: 00 00 01
{
  // Method begins at RVA 0x2050
  // Code size 13 (0xd)
  .maxstack 8
  IL_0000: /* 00 |            
*/ nop
  IL_0001: /* 72 | (70)000001 */ ldstr "Hello world"
  IL_0006: /* 28 | (0A)000004 */ call void [mscorlib]System.Console::WriteLine(string)
  IL_000b: /* 00 |            
*/ nop
  IL_000c: /* 2A |            
*/ ret
}

To build the byte array for SetException, I‘d suggest taking a couple of minutes
to read ECMA spec partiton II (25.4.6) first. The Flags/TryOffset/TryLength/HandlerOffset/HandlerLength
... can be retrieved from MethodBody.ExceptionHandlingClauses
programatically. Be aware the exception type token (ClassToken) has to be obtained
from GetTokenFor as well. Do you know Ildasm can show the raw exception information?
I did not know this until I learned about it recently from Peli.:) Uncheck View->Expand try/catch and check show bytes; we will
see something like the following at the bottom of the method IL:

// Exception count 1

.try IL_002e to IL_0051 finally handler IL_0051 to IL_0065
  // HEX: 02 00 00 00 2E 00 00 00 23 00 00 00 51 00 00 00 14 00 00 00 00 00
00 00
}

Class SignatureHelper offers a convenient way to construct the local variable
signature, if each local variable type is known. We can just make calls of SignatureHelper.AddArgument.

Are there any scenarios in your mind where using DynamicILInfo could be better than
using DynamicILGenerator? How‘d you like to construct those byte arrays? I am thinking
about writing and sharing a tool, which, based on an existing method, generates
C# code to define the equivalent dynamic method (using DynamicILInfo) (if this turns
out to be a popular scenario).