Partial methods, a new language feature in C#, has already generated some controversy. In a recent blog post, Alexander Jung summarizes some of the downsides and potential risks of partial methods.

In describing partial methods, Microsoft's Scott Wisniewski notes that they are a light-weight replacement for events, and are primary designed for use by automatic code generators, such as those found in Microsoft's new LINQ designer:

[Partial methods] are declared by creating a private method with an empty body and decorating it with the Partial keyword. The method may then be "re-implemented" elsewhere within its containing class. If the method is implemented, then the compiler will redirect all calls to the partial method to the implementing method. If the method is not implemented in its containing class, then the compiler silently removes any calls to it from the program...

Wisniewski also contrasts regular event-listeners, such as those found in Java, and partial methods. One such difference is that partial methods are a compile-time feature, allowing the compiler to ignore unimplemented partial methods:

The wiring of partial methods ... is always done at compile time, and an implementing method is associated with its declaring method by simply writing a method with the same name and signature as the partial method. Once this is done, all references to the partial method are rewritten by the compiler to refer to its implementing method... If a partial method does not have an implementing method then the compiler will simply optimize away any calls to it...

As Microsoft increasingly focuses its efforts around code generators that aid in the development process, partial methods are an important link between a code generator and a compiler, and can help produce more effective generators. Yet, as many developers have noted, partial methods may make C# more complex for most developers. Alexander Jung, for example, points out in recent blog post, Partial Methods for Partial Developers, that:

The usual (probably the only relevant) use case for partial methods is light weight event handling in combination with code generation. Say, you parse a database or an XML file and generate data classes. Tens of classes, hundreds of properties, all fairly generic, boilerplate stuff. And also fairly common is the need to interfere with this method for validation or that property setter to update another one. So instead of manipulating the generated code or having hundreds of events and thousands of method calls during runtime (of which in most cases only a tiny fraction will actually do something) partial methods kick in...

Unless I enter the camp of the not-so-common-code-generator-writing-developers (it happens, but only rarely), I can see no relevant use case that allows me to employ partial methods. (I really don’t count the example of increasing the readability conditional compilation as relevant for a new language feature.)

What do you think C#'s partial methods? More generally, what do you think of adding features to a language to aid automatic code generators, even if the feature makes the language more complex for most developers?