Extension Methods in C#, or How to Easily Extend an Existing Type

When writing applications, you will often use ready-made libraries and classes that were written by other people and you will not have access to their source code. If you need a method that is not in a given class, you will probably not look for its author, but will try to add such a method yourself. You're probably wondering how you can do this. The first thing you probably thought was that if you need to extend a class, you need to use inheritance or composition. Also in the case of inheritance, you would have to add a new class that will inherit from the class you want to extend and in it you can add a new method and write its implementation. Of course, this method is not ideal, because you will have to create a lot of new classes and you will have to change all the calls in your code. You can also, instead of using inheritance and composition, write a new method that will accept a given class as a parameter and, based on its value, perform some action and then return the appropriate value. Is there a better solution? Yes, this is where extension methods come in handy. Learn about what extension methods are and how to use them in your code in this article.

The problem we want to solve

Solution 1 - Adding a regular static method to the project

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            var description = "12345678901234567890X";
            var shortDescription = StringMethods.GetTheFirstNCharacters(description, 20);
            Console.WriteLine(shortDescription);
            ///12345678901234567...
        }
    }

    public static class StringMethods
    {
        public static string GetTheFirstNCharacters(string val, int maxNumberOfCharacters)
        {
            if (string.IsNullOrWhiteSpace(val))
                return string.Empty;

            if (val.Length <= maxNumberOfCharacters)
                return val;

            return val.Substring(0, maxNumberOfCharacters - 3) + "...";
        }
    }
}

As you can see, this solution meets all the assumptions, but is it perfect? No, I think this solution can be written better, thanks to extension methods. So what should this solution look like?

Solution 2 - Using the extension method

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            var description = "12345678901234567890X";
            var shortDescription = description.GetTheFirstNCharacters(20);
            Console.WriteLine(shortDescription);
            //12345678901234567...
        }
    }

    public static class StringExtensions
    {
        public static string GetTheFirstNCharacters(this string val, int maxNumberOfCharacters)
        {
            if (string.IsNullOrWhiteSpace(val))
                return string.Empty;

            if (val.Length <= maxNumberOfCharacters)
                return val;

            return val.Substring(0, maxNumberOfCharacters - 3) + "...";
        }
    }
}

As for the logic, there are no changes here, but in this case I used an extension method, thanks to which the string class was extended with a new method. You can use the GetTheFirstNCharacters method like a regular string class method. This method is also suggested by intellisense after entering a dot after the variable name. It seems to me that such a notation is much more legible and universal. You don't need to call any static methods from other classes here, you just call the extension method like any other method of the string class. Moreover, you can separate such extension methods into a separate project and use them in your other applications, if necessary.

How to write extension methods?

• It must be implemented in a static class
• The extension method must be static
• The first parameter of an extension method must be preceded by the this keyword before the name of the class it extends
  
  

Importantly, note that we do not pass the first argument to the extension method, which is preceded by the word this, because that is the type we are extending. It also calls our method on this type. This value is passed automatically.

If intellisense does not suggest the syntax, i.e. it does not show your method, then probably (if you have defined the extension method correctly) the method was written in a different namespace, so you also need to add the appropriate using in this file.

I often use such extension methods in my projects. I always stick to the convention that a given extension method is in a class called: extended type + Extensions suffix. That is, for a string, it will be a class called StringExtensions as in the example above. Such methods and the appropriate project structure increase the readability of the code.

Examples of extension methods

var myNumbers = new List<int> { 1, 2, 3 };
myNumbers.Sum();

This is what the Sum method signature looks like:

public static int Sum(this IEnumerable<int> source);

As you can see, this is a method that extends the IEnumerable class.

SUMMARY: