Extension Method in C#. Everything You Need To Learn

A C# extension method allows developers to extend the functionality of an existing type without creating a new derived type, recompiling, or otherwise modifying the original type. C# extension method is a special kind of static method that is called as if it was an instance method on the extended type. In this article, we will create a class library and extend its functionality from the caller code by implementing extension methods in C#.

C# Extension Method

C# extension method is a static method of a static class, where the "this" modifier is applied to the first parameter. The type of the first parameter will be the type that is extended.

Extension methods are only in scope when you explicitly import the namespace into your source code with a using directive.

Create a Class Library

Create a project Class Library project in Visual Studio.

Add the following code to Class 1. Class 1 has two methods, Display and Print.

using System;  
using System.Text;  
  
namespace ClassLibExtMethod  
{  
    public class Class1  
    {  
        public string Display()  
        {  
            return ("I m in Display");  
        }  
  
        public string Print()  
        {  
            return ("I m in Print");  
        }  
    }  
}

Create a Caller Application

Now create a console application in Visual Studio using New Project. Select File > New > Project and select Visual C# and Console Application, as shown below.

Add the reference of the previously created class library to this project.

Use the following code and use the ClassLibExtMEthod.dll in your namespace:

using System;  
using System.Text;  
using ClassLibExtMethod;  
  
namespace ExtensionMethod1  
{  
    public static class XX  
    {  
         public static void NewMethod(this Class1 ob)  
        {  
            Console.WriteLine("Hello I m extended method");  
        }  
    }  
  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Class1 ob = new Class1();  
            ob.Display();  
            ob.Print();  
            ob.NewMethod();  
            Console.ReadKey();  
        }  
    }  
}

In the above code, you see a static class XX with a method, NewMethod. If you notice, the NewMethod takes Class1 as a parameter. This is how you extend an existing library and add your methods. Now, this New Method is available via the class library.

When you use Visual Studio Intellisense, you can see the extension method is represented with an arrow (different from the normal method sign) since they were instance methods on the extended type. See the figure below:

The output of the preceding program looks like the following.

Benefits of extension methods

• Extension methods allow existing classes to be extended without relying on inheritance or changing the class's source code.
• If the class is sealed, there is no concept of extending its functionality. For this, a new concept is introduced, in other words, extension methods.
• This feature is important for all developers, especially if you would like to use the dynamism of the C# enhancements in your class's design.

More code snippets of extension expansion methods

using System;  
using System.Text;  
  
namespace ExtensionMethod2  
{  
    public static class ExtMetClass  
    {  
        public static int IntegerExtension(this string str)  
        {  
            return Int32.Parse(str);  
        }  
    }  
  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            string str = "123456";  
            int num = str.IntegerExtension();  
            Console.WriteLine("The output using extension method: {0}", num);  
            Console.ReadLine();  
        }  
    }  
}

In the preceding program, we used an extension method IntegerExtension(), to convert a string to a numeric type.

Important points for the use of extension methods

• An extension method must be defined in a top-level static class.
• An extension method with the same name and signature as an instance method will not be called.
• Extension methods cannot be used to override existing methods.
• The concept of extension methods cannot be applied to fields, properties, or events.
• Overuse of extension methods is not a good style of programming.

Conclusion

I hope this article will help you to understand Extension Methods in C# 3.0 and above. If you want to learn more about Extension methods, here is another use case: Create and Use an Extension Method in C#