Anonymous Methods - Behind the Scenes

Introduction

I think one of the most mysterious things in the software development world is compilers. Let's talk about C# compiler specifically.

C# compiler was written in C++ for historical reasons. C# compiler takes source files, then generates IL code. But we don't know what's going on inside C# compiler when generating IL code. In this process, C# compiler also creates different kinds of new structures.

Anonymous Methods - Behind the Scenes

Anonymous methods provide us to define unnamed methods and most common usage of anonymous methods is delegates.

For example,

btnLambda.Click += (_sender, _args) =>
{
    MessageBox.Show("This is an anonymous function");
}; 

Simply, this statement adds an event handler to the button's click event. But what's going on behind the scenes? Does the compiler make extra translations?

Firstly, we open this application with reflector.

We see that the compiler has generated a different method and delegate named as <WindowLoaded>b__0 and CS$<>9__CachedAnonymousMethodDelegate1. This method includes anonymous method's inline statement.

If we put this event handler assignment into Loaded event of a WPF Window, we can see generated IL code like below:

Simply, in this method first, the compiler creates a delegate which takes generated static method as parameter and then adds this delegate as Button's click event handler.

Using Local Variables in Anonymous Methods

I think using local variables in anonymous methods is the most important feature of anonymous methods. If we add a delegate to an event as event handler explicitly, we can't use any local variables inside this method which assignment operation made in.

Let's demonstrate this scenario.

private void Window_Loaded(object sender, RoutedEventArgs e)
{
     int x = 10;
     double y = 198.30;
     btnLambda.Click += (_sender, _args) =>
     {
         MessageBox.Show(String.Format("This is an anonymous function 
             result={0}",(x*y)));
     };
}

In this method, anonymous method uses local variables which are defined in method that event handler assignment made in.

Now let's look at the new class view of the project with reflector again.

In this scenario, the compiler generates a new type named <>c__DisplayClass1. This type includes 2 fields which we used in anonymous method declaration and also includes a method declaration that performs actions we specified in anonymous method declaration as we discussed in the previous section.

Window_Loaded method in IL codes:

In this method firstly, compiler generates new <>c__DisplayClass1 object, then assigns field values. And finally, the compiler creates a delegate by giving method which locates in <>c__DisplayClass1 type and adds this delegate to button's Click event as event handler. If we use a local object reference in an anonymous method, the scenario will be the same. Compiler-generated type will include relevant fields in order to access used object.

Conclusion

As you see, compilers are really mysterious. When programming languages provide some new features, the compiler deals with some extra translations and makes the developer's life easier.

Maybe that's why I love compilers and programming languages. :)

Hope this helps !

History

• 9^th February, 2011: Initial post