The random thoughts of a software developer
MISL - 5. Lambda Expressions
This is the last of the "tutorial" posts on MSIL. There is a massive amount that I have not had time to cover here but this is, as I said in my first post, the story of my journey through MSIL. You will find the source code for this blog post on my subversion repository. For this one last time I want to carry on the Calculator for one final time. This time I want to explore the use of Lambda expressions and to introduce a pattern similar to the one that I will make use of in later posts. The implementation of the Calculator interface then looks identical for each method:
// Generated class
public class Calc : Calculator
{
public int Add(int a, int b)
{
int result = 0;
Evaluator.Evaluate(() => result = a + b);
return result;
}
...
}
public delegate void CalcFunction(int a, int b);
public static class Evaluator
{
public static void Evaluate(CalcFunction codeBlock)
{
codeBlock();
}
}
Defining the Lambda Expression
As always, the first task is to make a test implementation in order use ILDASM to see what has been generated. Looking at the generated type TestCalculator there are four nested types:- <>__DisplayClass1
- <>__DisplayClass4
- <>__DisplayClass7
- <>__DisplayClassa
Why can't I use the generated type yet?
Once the nested type has been created it must surely be a usable type? When generating the code that will call this lambda expression I initially expected to be able to use Type.GetConstructor(), Type.GetMethod() and Type.GetField() to get access to the required members of the lambda expression. I was wrong, the first thing I needed to do was to delcare a local of the lambda expression type but I get the exception:
System.TypeLoadException: Could not load type 'Calculator' from assembly 'Calculatorb1d3a726-fa47-47cc-b190-ff5403de4ad7, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
at System.RuntimeTypeHandle.GetDeclaringType(RuntimeType type)
at System.RuntimeType.RuntimeTypeCache.GetEnclosingType()
at System.RuntimeType.get_DeclaringType()
at System.Reflection.Emit.ModuleBuilder.GetTypeRefNested(Type type, Module refedModule, String strRefedModuleFileName)
at System.Reflection.Emit.ModuleBuilder.GetTypeTokenWorkerNoLock(Type type, Boolean getGenericDefinition)
at System.Reflection.Emit.ModuleBuilder.GetTypeTokenInternal(Type type, Boolean getGenericDefinition)
at System.Reflection.Emit.SignatureHelper.AddOneArgTypeHelperWorker(Type clsArgument, Boolean lastWasGenericInst)
at System.Reflection.Emit.SignatureHelper.AddArgument(Type argument, Boolean pinned)
at System.Reflection.Emit.ILGenerator.DeclareLocal(Type localType, Boolean pinned)
at System.Reflection.Emit.ILGenerator.DeclareLocal(Type localType)
at LambdaExpressions.Program.DefineMethod(MethodInfo method, TypeBuilder typeBuilder, LambdaExpressionDetails lambdaExpression) in D:\code\dotNet\BlogDemos\Reflection\LambdaExpressions\Program.cs:line 150
at LambdaExpressions.Program.Main(String[] args) in D:\code\dotNet\BlogDemos\Reflection\LambdaExpressions\Program.cs:line 54
- ConstructorBuilder inherits ConstructorInfo
- MethodBuilder inherits MethodInfo
- FieldBuilder inherits FieldInfo
Making the call
The creation of the type and the initial definition of the methods of the ICalculator interface should be identical to that in previous posts; it is only the implementation that will differ. The four methods again look very similar, the only difference between them is the lambda expression that they are using:
var result = 0;
Evaluator.Evaluate(() => result = a * b);
return result;
- Declare a lamdba expression local variable
- Declare the result local variable
- Create a new instance of the lambda expression using the LambdaExpressionDetails.Constructor property
- Save it to the lambda expression local variable
- For each argument:
- Push the lambda expression local variable onto the stack
- Push the appropriate argument onto the stack
- Store the value into the appropriate field on the lambda expression using the LambdaExpressionDetails.Method property
- Load the lambda expression local variable
- Load the function pointer to the method of the lambda expression using
- Create a new instance of the CalcFunction delegate
- Call the Evaluator.Evaluate() method
- Load the result field
- Return the result
// Create the lambda expression object
il.Emit(OpCodes.Newobj, lambdaExpressionDetails.Constructor);
il.Emit(OpCodes.Stloc_0);
// Load all of the parameters into the lambda expression's fields
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld,
lambdaExpressionDetails.ParameterFields
.SingleOrDefault(x => x.Name.Equals("a")));
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld,
lambdaExpressionDetails.ParameterFields
.SingleOrDefault(x => x.Name.Equals("b")));
il.Emit(OpCodes.Nop);
// Set up the return value
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Stfld, lambdaExpressionDetails.ResultField);
// Make the call
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldftn, lambdaExpressionDetails.Method);
var constructorInfo = typeof(EvaluationDelegate)
.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
il.Emit(OpCodes.Newobj, constructorInfo);
var methodInfo = typeof(Evaluator)
.GetMethod("Evaluate", new[] { typeof(EvaluationDelegate) });
il.Emit(OpCodes.Call, methodInfo);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldfld, lambdaExpressionDetails.ResultField);
il.Emit(OpCodes.Stloc_1);
il.Emit(OpCodes.Br_S, label);
il.MarkLabel(label);
il.Emit(OpCodes.Ldloc_1);
il.Emit(OpCodes.Ret);