So, to convert an extension method to static method all you have to do is remove the this keyword from the signature.
However, if you want to convert a static method into an extension methods you have to:

In summary, he concludes that after compilation, there is no difference between the generated IL code for a static method and the code for an extension method.
The this keyword is there to instruct the compiler to put some meta data around the extension method.

My guess is that they have gone for the this keyword because 1.it already existed and 2. its existing meaning best fitted in the context of the extension method compared to the other existing keywords.

Maybe add something that the OP can call the function this way: e.GetFormattedErrorMessage().
–
MarlonMay 24 '12 at 3:04

Sorry if this sounds like a dumb question but can you guess any reason why it was coded this way. Also if I wanted to change this to a static method, how could I do that and what would be the disadvantage?
–
Samantha JMay 24 '12 at 3:04

@SamanthaJ extension methods are static methods, and they may be called using either the normal static method syntax or the extension method (quasi-instance-method) syntax. For that reason, I believe, the current example will not compile, though I don't have a compiler handy to check.
–
phoogMay 24 '12 at 3:57

@SamanthaJ yes, you are right. I typed the example straight into the browser. I have edited the answer.
–
Pencho IlchevMay 24 '12 at 4:03

I checked the code on ideone, and in fact it doesn't compile, so -1.
–
phoogMay 24 '12 at 4:04

because that's how you define an 'extension' method. it lets the compiler know that this particular method should be allowed to be called directly on an object, it lets you write code like this:

GetFormattedErrorMessage(e);

instead as:

e.GetFormattedErrorMessage();

i'm not sure why the code you posted is calling the function in that way. you should be able to call the function directly on the exception object. extension methods are essentially ways to extend behavior of built in classes/types that you otherwise wouldn't be able to modify.