Back To Basics - Extension Methods in C# - A Brief Note

By Anoop Madhusudanan

Vote on HN

About Back To Basics - It's often good to look back and fill any gaps we might be having, in certain aspects of the language or framework we use. I'll be examining and blogging about some well known features of C# and .NET, in Back To Basics series - Probably in a bit more detail.

Extension methods, introduced in Orcas, seems very interesting. First of all, here is a brief look at what they are. Extension methods can be created for existing framework classes, or for the classes that you created yourself.

For instance - one fine day, I might think that for my console application; the Framework’s String class should have a Dump method for allowing me to dump the string directly to the console.
So I’ll go ahead and create an extension method called Dump.

Using this key word in the parameter signature tells the compiler to apply our Dump extension method to the String class. Also, note that both the Dump extension method and the StringExtensions class where we define the extension method, are static.
Now, I can import the namespace ExtensionDemo.Extensions and our Dump extension method will be ‘mapped’ to the type you specified using this keyword in the parameter signature of your extension method – i.e, the String class.
You can go ahead and call your extension method, much like you call any other method defined in the String class, as shown below.

Note that there is a small arrow in intellisense near the Dump method, which represents that it is an extension method. Also, as you might know, even this is possible.

Run the application, and you see the string in the console.
Remember that Extension methods are a compiler feature. The compiler will expand an extension method call to a static method call when the application is compiled. Hence, you might say an extension method is a new way of writing static methods that can be called using instance method invocation syntax.
IL generated for the above extension method and method invocation will be equivalent to having a static method Dump() in StringExtensions class, and invoking the same using conventional static invocation, like this
//Conventional way to do what ever we've done earlier
//using extension methods


using System;

namespace ExtensionDemo.Extensions
    public static class StringExtensions
        //A simple old style static method

        public static void Dump(String stringToDump)

//Old way of invoking the static method

using System.Text;
using ExtensionDemo.Extensions;

namespace ExtensionDemo
    class Program
        static void Main(string[] args)
            string myString = "hello";

Here are few more pointers I can put together.
  • If you already have an instance method in your class with the same signature of an extension method you apply, the compiler will bind your call against the instance method.
  • Extension methods are brought into scope at the namespace level. In simple words, you can’t call the method Dump() on a string, if you don’t import the namespace where we have the static class with the extension method Dump() in it.
  • You should not use Extension methods to extend a class, if you can do that using some other means, like inheritance.
  • As you might assume, Extension methods can’t access private members of the type (because the type instance is passed as a parameter).
  • If the type you are applying the Extension method changes your code might break. For example, assume that you are accessing a property PropertyA in your extension method, and tomorrow some one changes the property name to PropertyB
  • Use Extension method sparingly and judiciously.
    Will be posting more on combining Lambda expressions with Extension methods, and finally some insights on LINQ as well.


  1. "As you might assume, Extension methods can’t access private members of the type"

    Damn, I guess it's not really "extending" then is it? I can't think of too many situations where this feature would be useful over existing methods. I suppose it can clean the syntax up a bit though.

  2. Yes. But think about this. It is the only way to really 'extend' a compiled class :). As I explained in my example, you can use this to write custom methods for Framework classes. For example, LINQ uses extension methods to add methods like Where, Select etc to the existing IEnumerable interface.


Please keep your comments clean.

© 2012. All Rights Reserved.