Free-ebooks-library - Bahar Ali Khan

have replaced the call to EmitWriteLine with this, and we would have gotten the
same result:
MethodInfo writeLineStr = typeof (Console).GetMethod ("WriteLine",
new Type[] { typeof (string) });
gen.Emit (OpCodes.Ldstr, "Hello world"); // Load a string
gen.Emit (OpCodes.Call, writeLineStr); // Call a method
Note that we passed typeof(Test) into DynamicMethod’s constructor. This gives the
dynamic method access to the nonpublic methods of that type, allowing us to do
this:
public class Test
{
static void Main()
{
var dynMeth = new DynamicMethod ("Foo", null, null, typeof (Test));
ILGenerator gen = dynMeth.GetILGenerator();
MethodInfo privateMethod = typeof(Test).GetMethod ("HelloWorld",
BindingFlags.Static | BindingFlags.NonPublic);
gen.Emit (OpCodes.Call, privateMethod); // Call HelloWorld
gen.Emit (OpCodes.Ret);
dynMeth.Invoke (null, null); // Hello world
}
static void HelloWorld() // private method, yet we can call it
{
Console.WriteLine ("Hello world");
}
}
Understanding IL requires a considerable investment of time. Rather than understand
all the opcodes, it’s much easier to compile a C# program then to examine,
copy, and tweak the IL. An assembly viewing tool such as ildasm or Lutz Roeder’s
Reflector is perfect for the job.
The Evaluation Stack
Central to IL is the concept of the evaluation stack. The evaluation stack is distinct
from the stack used to store local variables and method parameters.
To call a method with arguments, you first push (“load”) the arguments onto the
evaluation stack, and then call the method. The method then pops the arguments
it needs from the evaluation stack. We demonstrated this previously, in calling
Console.WriteLine. Here’s a similar example with an integer:
var dynMeth = new DynamicMethod ("Foo", null, null, typeof(void));
ILGenerator gen = dynMeth.GetILGenerator();
MethodInfo writeLineInt = typeof (Console).GetMethod ("WriteLine",
new Type[] { typeof (int) });
// The Ldc* op-codes load numeric literals of various types and sizes.
708 | Chapter 18: Reflection and Metadata