This is the article in continuation of my article series about the methods in C#. In my previous articles I have discussed about the constructors and operator overloading methods. Extension methods is a feature which was introduced in C# 3.0. Extension methods in C# are used to extend the functionality of a class which is not provided by the class itself, without altering the definition of the original type.
An 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.
Please find the example of the extension methods in C#, in the code snippet provided below whose utilization I will be discussing down the line.
public static class StringExtension
{
public static string CapitalizeFirstCharacter(this string strPara)
{
StringBuilder capitalizedString = new StringBuilder();
string[] allWords = strPara.Split(null);
foreach (string item in allWords)
{
capitalizedString.Append(Regex.Replace(item, @"^\w", m => m.Value.ToUpper()) + " ");
}
return capitalizedString.ToString();
}
}
Extension Method Utilization:
As I have already discussed, Extension methods are used to extend the functionality of the existing class. I have created an extension method for the String class to get the first letter in upper case of each word in the string.
string myName = "my name is vikram";
string firstCharacterUpper = myName.CapitalizeFirstCharacter();
Console.WriteLine(firstCharacterUpper);
Console.ReadKey();
And the output of the above code will be as following.
Suppose if the extension methods would not have been in existence, in that case we had to create a static class and defined a static method in the same class. The method CapitalizeFirstCharacter, would have been defined in our case as shown below
public static class StringExtension
{
public static string CapitalizeFirstCharacter(string strPara)
{
StringBuilder capitalizedString = new StringBuilder();
string[] allWords = strPara.Split(null);
foreach (string item in allWords)
{
capitalizedString.Append(Regex.Replace(item, @"^\w", m => m.Value.ToUpper()) + " ");
}
return capitalizedString.ToString();
}
}
Now there is no problem with this approach but it is not ideal from programmer’s point of view. The first problem with this traditional approach is that, the developer would not know if there is a method which exists in some static class which helps us to achieve the desired functionality. The second problem with this approach is that the static class and static method overpowers and detracts a programmer’s mind from the operation that is performed.
But if we look at the first approach of the usage of extension methods, we can see that Visual Studio’s intellisense provides the ease to see the function while working on the string class as shown in the figure below. As we can see the extension methods exists with a special symbol i.e. a down arrow next to it and the tooltip really shows that it is an extension method.
And now while using the extension methods we are pretty sure about the operation that we want to execute on the string class.
How does compiler knows about the extension Methods ?
When the compiler sees the the code in the following line :
The compiler first checks if the String class or any of the base classes offers an instance method called CapitalizeFirstCharacter() that takes single parameter of type string. If an existing methods exists, then the compiler emits the code to call it. If no matching instance is found, then the compiler will look at any static classes that define static method called CapitalizeFirstCharacter() that takes their first parameter as a type matching the type of the expression being used to invoke the method i.e. a string in our case.
Rules to Use Extension Methods:
We need to import the namespace in which the static class is defined which contains the extension methods. Suppose if I have defined my CapitalizeFirstCharacter method in a class StringExtension which is again defined in under namespace In that case we need to include the namespace using the keyword using wherever we want to use the CapitalizeFirstCharacter method.
C# only supports extension methods, it does not support extension properties, extension events, extension operators.
Extension methods must be declared in non-generic and static classes.
Extension methods cannot access the private state or methods of target instance.
Cannot hide, replace or override instance methods.Compiler only looks for extension methods when it finds no compatible instance methods.
C# compiler looks only for the extension methods defined in static classes that are themselves defined at the file scope. In other words if we define a static class in some class and then define our extension methods, in that case we will get a compile time error as shown below.
It is possible that multiple static classes can implement same extension method.In that case we will get a compile time error as shown below.The only way to overcome this error is to change the source code.
If we are extending a type with some extension methods in C#, in that case all the derived types are also eligible for this method’s utilisation. Suppose if we are extending System.Object then all the types will have that particular extension method. That is why we should use this feature very sparingly and with caution.
Conclusion
In this article I have discussed all the important points related to extension methods and I believe that I have made the concepts about them quite clear.
Please let me know your feedback about the article.
