C# 2.0 - Anonymous Methods

Let's get back to my series on the evolution of the C# language.

Everybody is familiar with what a delegate is, right? We know that delegates are a big part of the events system in .Net. We register a method on that delegate (called handler) that is invoked when the delegate is invoked. In other words, a delegate simply points to a method. The advantage here is that, as the delegate wraps the method and is an object, we can simply pass it to a method as a parameter! Think about this:

	void Main()
	{
	MyDelegate mydel = Method1; //Register first method -> implicity creates delegate instance.
	mydel += Method2; //Register second method
	mydel(); //we could pass this instance to a method and invoke it this way
	}
	public void Method1()
	{
	Console.WriteLine("Method1 Called");
	}
	public void Method2()
	{
	Console.WriteLine("Method2 Called");
	}
	public delegate void MyDelegate ();

view raw Named Methods hosted with ❤ by GitHub

This is how we use a delegate in events, for instance. The class exposes the delegate and we register our method to listen it. When the delegate is called inside the class, all the registered methods will be called (because of this, we call it a Multicast Delegate). This works well, because all you have to do is have a method with the required signature.

In the example above, we needed to declare two methods just to make a Console.WriteLine. Isn't this too much? I think it's a bit too much having to create methods to such simple things. Sometimes we encapsulate some one-line piece of logic, but i think creating a method for it feels like overdoing it . What we can do in this situation is use the C# 2.0 Anonymous Methods syntactic sugar. This will allow this code:

	void Main()
	{
	MyDelegate mydel = delegate() { Console.WriteLine("Method1 Called"); };
	mydel += delegate() { Console.WriteLine("Method2 Called"); };
	mydel(); //Call the delegate which calls all the methods
	}
	public delegate void MyDelegate ();

view raw Anonymous Methods hosted with ❤ by GitHub

See how much cleaner this is now? We just used an anonymous method to assign to a delegate and never had to declare that nasty method. Of course, the signature of the anonymous method still needs to match with the delegate, or a compiler will throw an error. You can pass parameters inside that delegate() call, just like you would for the named method.

Delegates are useful to maximize encapsulation and keep code simple. You can use them if, say, a class needs the ability to execute multiple methods from outside sources with just one call. It is very simple to use this kind of features, and, when properly designed, an application can benefit a lot from this, as this can be an interesting extensibility point.

Keep coding!