Compiled Expression Trees misunderstanding?

Question

I have this expression :

Expression<Func<string, bool>> f = s => s.Length < 5;

ParameterExpression p = Expression.Parameter (typeof (string), "s");
MemberExpression stringLength = Expression.Property (p, "Length");
ConstantExpression five = Expression.Constant (5);
BinaryExpression comparison = Expression.LessThan (stringLength, five);
Expression<Func<string, bool>> lambda= Expression.Lambda<Func<string, bool>> (comparison, p);

//lets : test

Func<string, bool> runnable = lambda.Compile();
Console.WriteLine (runnable ("kangaroo")); // False
Console.WriteLine (runnable ("dog")); //True

I want to ask about the .Compile()

What does it compile ? And what is the difference between the first execution vs later executions...?

Compile should be something that happens once and not happens again later ....

What / How does it help me ?

Answer 1

When you are building the expression tree at runtime there's no code emitted. It's a way to represent .NET code at runtime.

Once you call the .Compile method on the expression tree the actual IL code is emitted to convert this expression tree into a delegate (Func<string, bool> in your case) that you could invoke at runtime. So the code that this expression tree represents can be executed only after you compile it.

Calling Compile is an expensive operation. Basically you should be calling it once and then caching the resulting delegate that you could use to invoke the code many times.

Answer 2

The Expression<Func<string,bool>> is only a representation of an expression, it cannot be executed. Calling Compile() gives you a compiled delegate, a piece of code that you can call. Essentially, your program composes a small code snippet at runtime, and then call it as if it were processed by the compiler. This is what the last two lines of your code do: as you can see, the compiled snippet can analyze the length of the string that you pass in - when the length is less than five, you get a True back; when it's five or more, you get a False.

What happens on first execution of the compiled snippet is platform-dependent, and should not be detectable by programmers using the .NET platform.