Neil Cowburn - OpenNETCF

It's always useful to learn something new everyday. It keeps you fresh and on your toes. Even after 6 or so years of using .NET, I'm still learning new, useful nuggets. This one is a gem, though.

If you look at the constructor signatures for the System.Threading.Thread class, you'll find something like this:

The Thread class constructor takes an instance of a ThreadStart delegate, so naturally, you code this:

new Thread(new ThreadStart(MyThreadDelegate));

where MyThreadDelegate is a method with the same signature as the ThreadStart delegate. Easy, right? Of course, but there is another way...

new Thread(MyThreadDelegate);

This example is functionally the same as the previous example! This is called implicit method group conversion. Excellent, I can save a time and space by letting the compile infer the delegate type from the method signature. Nice! It turns out this is not just restricted to threading either. Anywhere in your code where you reference a delegate method, you can do this. For example, take a look at assigning an event handler:

The traditional way:

using System;

class Program
{
    public static event EventHandler MyEvent;

    static void Main(string[] args)
    {
        MyEvent += new EventHandler(MyEventHandler);
    }

    static void MyEventHandler(object sender, EventArgs e)
    {
    }
}

Using implicit method group conversion:

using System;

class Program
{
    public static event EventHandler MyEvent;

    static void Main(string[] args)
    {
        MyEvent += MyEventHandler;
    }

    static void MyEventHandler(object sender, EventArgs e)
    {
    }
}

Now that rocks! This is documented in Section 21.9 of The C# Programming Language (pp. 534-535).