M B A R K's Blog
Extension Methods in C#

Extension Methods in C#

M B A R K's photo
M B A R K
·

4 min read

Table of contents

Extension methods in C# allow developers to add new methods to existing types without creating a new derived type, recompiling, or modifying the original type. These methods are defined as static methods but are called as if they were instance methods on the extended type.

How to define an extension method

To define an extension method, you need to create a static class and define a static method that takes the type you want to extend as the first parameter. The parameter should be preceded by the this keyword.

For example, the following code defines an extension method IsEven() for the int type that checks if an integer is even:

public static class IntExtensions
{
    public static bool IsEven(this int number)
    {
        return number % 2 == 0;
    }
}

How to use an extension method

Once an extension method is defined, you can call it on an instance of the extended type just like a regular instance method.

For example, the following code uses the IsEven() extension method defined above:

int number = 4;
bool result = number.IsEven(); // result is true

Advantages of extension methods

There are several advantages to using extension methods:

  1. Extension methods allow you to add new methods to existing types without creating a new derived type. This can be useful when you don't have access to the source code of the type you want to extend.

  2. Extension methods can make your code more readable by allowing you to add methods that feel like they belong to the extended type.

  3. Extension methods can be used to add methods to types from third-party libraries or the .NET Framework itself, which can be useful if you want to add additional functionality without having to modify the original code.

Limitations of extension methods

There are also some limitations to extension methods that you should be aware of:

  1. Extension methods cannot override existing methods. If the extended type already has a method with the same name and signature as the extension method, the extension method will never be called.

  2. Extension methods have lower priority than instance methods. If the extended type has a method with the same name as the extension method, the instance method will be called instead of the extension method.

  3. Extension methods cannot access private members of the extended type.

Example: Extension methods for string manipulation

Here's an example of how extension methods can be used to add some useful string manipulation methods:

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        char[] charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }

    public static bool IsPalindrome(this string input)
    {
        return input.ToLower() == input.Reverse().ToLower();
    }
}

The Reverse() method takes a string and returns a new string with the characters reversed. The IsPalindrome() method checks if a string is a palindrome (a word or phrase that reads the same backward as forward).

These extension methods can be used like this:

string s = "racecar";
bool result1 = s.IsPalindrome(); // result1 is true

string t = "hello";
bool result2 = t.IsPalindrome(); // result2 is false

string u = "civic";
string reversed = u.Reverse(); // reversed is "civic"

As you can see, the IsPalindrome() method correctly identifies palindromes, and the Reverse() method correctly reverses the characters in a string.

Example: Extension methods for int manipulation

Here's another example of extension methods that add some common mathematical operations to the int type:

public static class IntExtensions
{
    public static int MultiplyByTwo(this int number)
    {
        return number * 2;
    }

    public static int MultiplyByThree(this int number)
    {
        return number * 3;
    }

    public static bool IsEven(this int number)
    {
        return number % 2 == 0;
    }

    public static bool IsOdd(this int number)
    {
        return number % 2 != 0;
    }
}

These extension methods can be used like this:

int x = 5;
int y = x.MultiplyByTwo(); // y is 10
int z = x.MultiplyByThree(); // z is 15
bool even = y.IsEven(); // even is true
bool odd = z.IsOdd(); // odd is true

As you can see, the extension methods MultiplyByTwo(), MultiplyByThree(), IsEven(), and IsOdd() are called just like regular instance methods on the int type.

Conclusion

Extension methods are a powerful feature in C# that allow you to add new methods to existing types without modifying the original code. They can make your code more readable and allow you to add additional functionality to types from third-party libraries or the .NET Framework. However, it's important to be aware of the limitations of extension methods, such as their lower priority compared to instance methods and their inability to access private members of the extended type.

C#