Why does this code work?

Sunday, Apr 25, 2010 2 minute read Tags: .net c# operator-overload
Hey, thanks for the interest in this post, but just letting you know that it is over 3 years old, so the content in here may not be accurate.

In the discussion on the Umbraco forum about using LINQ to Umbraco I posted a short code snippet of something we write fairly frequently at TheFARM using our version of LINQ with Umbraco.

I thought I’d post the challenge to my trusty followers, for them to see if they know why the code works. First off the code:

IEnumerable<XElement> nodes = UmbXmlLinqExtensions.GetNodeByXpath(...); 
IEnumerable<IUmbracoPage> pages = nodes.Select(n =>(IUmbracoPage)(UmbracoPage)n);

What the XPath being evaluated isn’t important, what is important is you’ll notice that we have a collection of System.Xml.Linq.XElement’s, but then it’s directly casting each XElement to IUmbracoPage.

Here’s the skeleton for the class and interface:

public interface IUmbracoPage { ... } 
public class UmbracoPage : IUmbracoPage { ... }

Again the body of the interface isn’t important, what is important is that the class only inherits from the interface, it does not inherit from XElement.

###Why does this work###

Well the answer is actually very simple, and it’s a really handy feature of the C# language, explicit operators.

Explicit operators allow you to define explicit casting between types. So the code that was missing from my original post was this:

public static explicit operator UmbracoPage(XElement x) {
    return new UmbracoPage(x);

What I’ve done here is defined how the compiler is to treat a casting of an XElement to an instance of UmbracoPage, and since UmbracoPage inherits IUmbracoPage there is already a defined casting to it.

Inside the body of my explicit operator I can do anything I desire, here I’m just returning a new instance, passing the XElement to the constructor.

I find it really quite elegant, and that it reduces code smell quite nicely.

But explicit operators also have a buddy, in the form of implicit operators (which was the close-but-no-cigar answer). These work by the type being defined by the assignment target, eg:

UmbracoPage page = xElement;

I’m personally not a fan of implicit operators though, I find them less obvious when you’re reading code.

So there you have it, a slightly obscure language feature to play with!