Driven by Development : MSIL

MSIL Part 3: Use arguments in IL

Geoffrey Samper — Wed, 02 Apr 2008 18:00:46 GMT

In part two I explained how to use locals in IL today I will show you how to use a arguments in IL.

Here is the method that we will define in IL. There is no advantage of defining a method like this in IL but for this post it's sufficient.

1 public string OneArgumentInCSharp(string date) 
2 {
3             return "It's " + date;
4 }

 1 DynamicMethod dm = new DynamicMethod("UseArgumentInIl", typeof(string), 
 2     new Type[] { typeof(string) });
 3 ILGenerator generator = dm.GetILGenerator();
 4 
 5 MethodInfo concatMethod = typeof(string).GetMethod("Concat",
 6     new Type[] { typeof(string), typeof(string) });
 7 
 8 generator.Emit(OpCodes.Ldstr, "It's ");
 9 generator.Emit(OpCodes.Ldarg_0);
10 generator.EmitCall(OpCodes.Call, concatMethod,null);
11 generator.Emit(OpCodes.Ret);
12 
13 Func<string, string> func;
14 func = (Func<string, string>)dm.CreateDelegate(typeof(Func<string, string>));
15 
16 string result = func(DateTime.Now.ToLongDateString());
17 Console.WriteLine(result);

Code sample 2 is the code that generates code sample 1 at runtime here the explication what it does.

(Line 1) Create an instance of the DynamicMethod Type so that it is possible to inject IL at runtime. The DynamicMethod needs to know the signature of the method this must be specified in the constructor. In this case the return type is void and it has no parameters.

(Line 8) The Ldstr loads a string on the evaluation stack in our case this is "It's ".

(Line 9) To opcode to use arguments is Ldarg.Because the method has only one parameter it's possible to use the shortcut OpCode ldarg_0. This load argument at index 0 on the evaluation stack.

(Line 10) Now the concat method has to be called to concatenates the two strings.

(Line 14) Invoke the method that is generated..

MSIL Part 2: Define a local in IL

Geoffrey Samper — Wed, 26 Mar 2008 20:05:20 GMT

In part one I explained how to call a method from IL today I will show you how to define a local variable in IL and use it.

Here is the method that we will define in IL. There is no advantage of defining a method like this in IL but for this post it's sufficient

Code sample 2 is the code that generates code sample 1 at runtime here the explication what it does.

(Line 1) Create an instance of the DynamicMethod Type so that it is possible to inject IL at runtime. The DynamicMethod needs to know the signature of the method this must be specified in the constructor. In this case the return type is void and it has no parameters.
(Line 5) We need to define a local variable this can done by using the DeclareLocal method of the ILGenerator class. It requires the type of the local as a parameter. The local will be defined in the variable list at index 0.
(Line 7) The ldstr opcode let push a string on the evaluation stack. In this case it put "this variable is defined in IL" on the evaluation stack.
(Line 8) We need to store the string from Line 7 in the local variable this is possible by the Stloc opcode. In this case we use the Stloc_0 it is a shortcut to store the result in the variable list at index 0.
(Line 9) We need to load the variable back on the evaluation stack so that we can call the the method WriteLine this can be done by using the LdLoc opcode.
(Line 10) Emit an opcode so that it calls the WriteLine method.
(Line 14) Invoke the method that is generated.

Want to learn IL (MSIL). The easy way and WHY (Part 1)?

Geoffrey Samper — Tue, 18 Mar 2008 21:47:00 GMT

The first question is why do you need know IL if you have C# VB.NET and other languages? My reason to learn IL is when I'm using Reflection it is often too slow. So I need to rely on Reflection.Emit. For the lucky developers there is a new way in .NET 3.5 and it is called Lambda Expressions.

So what can we do with generating IL on the fly.

Comparer that works for all your objects so that we can sort list of objects.
A method that could clone all your objects.

Without reflection this is not possible for writing a class that can do all these kind of stuff. A solution is using Standard reflection the drawback, it is pretty slow . Here comes Reflection.Emit to the rescue.

The Reflection.Emit has one nice feature and this is DynamicMethod this class let you generate a method at runtime.

Before we can begin with generating IL we need to learn IL so Kenny Kerr wrote a series of article that explains IL.

Now it time for generating a really simple method at runtime using IL. The method will print Hello World .

Code sample 2 is the code that generates code sample 1 at runtime here the explication what it does.

(Line 1) Create an instance of the DynamicMethod Type so that it is possible to inject IL at runtime. The DynamicMethod needs to know the signture of the method this must be specified in the constructor. In this case the return type is void and it has no parameters.
(Line 6) The ldstr opcode let push a string on the evaluation stack. In this case it put "Hello World" on the stack.
(Line 7) The call opcode let you call a method. To call a method it needs MethodInfo.
(Line 10) Call the CreateDelegate method of the DynamicMethod Type so that it can be invoked later.
(Line 11) Invoke the method that is generated.

Hope it help