C# Extension Methods Tutorial and Example

Although not all Object-Oriented Programming languages have the method extensibility feature enable, C# does have this feature enabled.

Extending a class to access a new and fully customizable method (created by the programmer) on an object without having to mess with the class definition (the source code) is possible by using the Extension Method feature. In other words, we add methods to existing types without modifying, recompiling or creating a derived class.

When is recommended to use Extension Methods?

Throughout the entire .NET Ecosystem, extension methods were introduced to promote code re-usability. Chances are, you will be in situations where you are not in control of the original source of the type you want to extend; also, it is most likely that you are dealing with a sealed (non-extensible) class. And what about situations where the functionality of the method should not be exposed beyond its applicable scope? Well, under these sort of circumstances, extension methods always come in handy.

A small Caveat to bear in mind.

There’s a risk you have to keep in mind when creating extension methods. Since we already mentioned that it is most likely that the type’s source code you want to extend is not under your control, things may go sideways when a change in the implementation of the type is applied; meaning, your extension method code will be on the line of breaking, forcing you to re-factor and recompile everything back.

Example

Another important thing about extension methods is that they only under the scope of the consumer. In the example above we are using a specific namespace ConsoleApp1.Extensions; this means, if Program.cs is in a different namespace, we will have to include the statement: using ConsoleApp1.Extensions;. We can tweak the extension class by declaring it under the System namespace, hence avoiding including the namespace in every consumer class. This is a practical approach because the String Type is defined under the System namespace in C#.

It’s actually pretty simple, but there are some rules we need to follow in order to extend a type in C#. Let’s extend the capabilities of the String class. We start by defining our StringExtensions class. A good naming convention is to use the actual type/class name followed by the word Extensions. The class must be a static class, meaning it cannot be instantiated. We’re defining a new method, Clean which wipes out any special character from the string object, that’s it.

using System;
using System.Text.RegularExpressions;

namespace ConsoleApp1.Extensions
{
    public static class StringExtensions
    {
        /// 

        /// Cleanses 
        /// 
        /// The string object
        /// A new string with all the special characters gone
        public static string Clean(this string myStr)
        {
            if (string.IsNullOrWhiteSpace(myStr)) return string.Empty;
            var specialChars = new Regex("[^(\\w )]", RegexOptions.Compiled);
            var newStr = specialChars.Replace(myStr, string.Empty);
            return newStr;
        }
    }
}

Line 13 defines the method signature. For any extension method we need use the this followed by the instance type and the object name (just a variable for the scope of the method). Be aware that this will define a non-parameterized method; if we were to define a parameterized method we need to enter the new parameters as normally right after the this string myStr convention parameter. It Might sound silly but it actually makes sense since we are telling the compiler that this method extends the type String functionality by invoking it from the current String instance.

Some defensive programming on line 15 and on 16 we’re telling the compiler to set a new regular expression that will look for any non-vowel character and non-whitespace. Every single match will be replaced with the string.empy value.

Once the definition is done. We can call the method on the object just as we would do with any other well-known String method. This is what Visual Studio (2019, with ReSharper extension) shows for autocomplete suggestion:

Our Program.cs looks like this

class Program
{
	static void Main(string[] args)
	{
		var test = "$This!@ is just an ;^";
		Console.WriteLine( test.Clean() );
	}
}

The result will be a new string without the special characters that were introduced in the original string object.

The matter of fact is that most likely you will end up consuming extensions methods rather that creating them. Microsoft suggest that we should only create extension methods only when it’s really necessary. One of the most popular Extension Methods Namespace in the C# and .NET world is definitely LINQ, the Language Integrated Query namespace which enables the capability for querying objects, specially of type IEnumerable.