Extension Methods
One of the features of C# 3.0 and VB.NET 9.0
The problem
Normally, in a situation where it is necessary to add more functionality to a class - for instance a new method - it would simply be a matter of modifying the class' source code and recompiling the binaries with these new changes to make this effect. However, in some cases, especially when it comes to classes that are build-in into the .NET-framework or reside in third-party assemblies, the programmer does not have access to the source code and is thus unable to change the behavior of the class directly. Heretofore, the programmer has been left with two other more limited and less intuitive (respectively) options:
- The first option is to inherit the class and then add the functionality.
- The second option is to make a new, separate class and add a static method that takes an object of the class type and return a new object with the modification of choice.
Current solutions
The first option is in principle easier, but it is unfortunately limited by the fact that many classes restricts inheritance of certain members or forbids it completely. This includes sealed class and the different primitive data types in C# such as int, float and string. The second option, on the other hand, does not share these restrictions, but it may be less intuitive as it requires a reference to a separate class instead of using the methods of the class in question directly.
As an example, lets consider a need of extending the string class with a new reverse method whose return value was a string with the characters in reversed order. Because the string class is a primitive type, the method would typically be added to a new utility class in a manner not unlike the following:
string x = "some string value"; string y = Utility.Reverse(x);
This may, however, become increasingly difficult to navigate as the library of utility methods and classes increases, especially for newcomers. The ___location is also less intuitive because, unlike most string methods, it would not be a member of the string class, but in a completely different class altogether. A better syntax would therefore be the following:
string x = "some string value"; string y = x.Reverse();
Extension Methods
in C# 3.0 you can configure the Util.Reverse() function to make the first code doable, so consider the following code of Util.
public static class Util
{
public static string Reverse(this string input)
{
char[] reversedChars = new char[input.Length];
for (int i = input.Length - 1, j = 0; i >= 0; --i, j++)
{
reversedChars[j] = input[i ];
}
return new String(reversedChars);
}
}
as you can see it is a simple static class, with one static function called Reverse, all what we have to do
- Make sure that the class is static
- Add this keyword before the type of the argument you want to extend.
so now you can write this code,
string x = "some string value"; string y = x.Reverse()