Hello World with DynamicILInfo

The following "Hello World" program shows how to use APIs in the class

DynamicILInfo. MSDN documentation will have more details on this class in
the next release.

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);

  }

  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);

  }

}

> csc.exe demo.cs

> demo

Hello world

The DynamicILInfo class is different from
ILGenerator. It directly uses byte arrays to set IL code,
exception, and the local signature. So how can we get those byte arrays?

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).