Extension Methods: More than Sugar

One of the enhancements in C# 3.0 is extension methods. Extension methods let you write static functions that look like they belong to other objects - even objects that you didn't write.

Some bloggers have criticised extension methods, saying that they're just syntactic sugar. Yes, they are syntactic sugar; but they're not just syntactic sugar.

Consider this extension method:

public static class Extender
{
public static void Foo(this Thing t)
{
//...
}
}

It tells the compiler to act as if the method Foo exists on class Thing:

Thing t = new Thing();
t.Foo();                 // A - what we write
Extender.Foo(t);         // B - what the
//compiler compiles 

But, that's not all the extension method means. It really means this:

Compile t.Foo() as Extender.Foo(t) unless class Thing defines its own method Foo(), in which case you should call that instead.

// When we write
t.Foo();    

// It compiles the same as this:
Extender.Foo(t);

// unless t.Foo() exists, 
// in which case if compiles
// to this, just as if the
//extension method never existed:
t.Foo();                

That's what makes extension methods more than just syntactic sugar. They allow you to create a "standard" implemenation of Foo, which is used by all objects except those that define their own specialised implementation instead.

That's an interesting concept - but there's a problem in Microsoft's proposed implementation. I'll write about it in my next post...