An extension method is a special static method, defined in a static class, but called as if it were an instance method of the type we are extending.
Imagine you are working with the system’s String class. Suddenly, you think: “I wish String had a .WordCount() method to count words directly”.
But you have a problem: You don’t have the source code for String. It’s a sealed (sealed) .NET class. You cannot inherit from it or modify it.
The “old” solution would be to create a StringHelper class with a static method:
int palabras = StringHelper.WordCount(miTexto); // Works, but it's ugly and breaks fluency
C#‘s elegant solution is Extension Methods. They allow us to “inject” new methods into existing types without modifying them or inheriting from them.
Although they are very powerful, don’t go crazy creating extensions for everything (“Extension Method Hell”).
Syntax: The this modifier
To create an extension method, we need to follow three rules:
- The containing class must be
static. - The method must be
static. - The first parameter of the method must have the keyword
thisfollowed by the type we want to extend.
Let’s implement the word counter example:
using System;
public static class StringExtensions
{
// Notice the 'this string str'
public static int ContarPalabras(this string str)
{
if (string.IsNullOrWhiteSpace(str))
return 0;
return str.Split(new char[] { ' ', '.', '?' },
StringSplitOptions.RemoveEmptyEntries).Length;
}
}
Now any string in our project (provided we import the namespace) will have this method available:
string miFrase = "Hola mundo, esto es C#";
// Call as an extension method (Fluid and readable)
int n = miFrase.ContarPalabras();
Under the hood it is syntactic sugar. The compiler does us the favor of translating our nice call into the static call without us knowing.
Extending interfaces
Where extension methods truly shine is not in extending concrete classes, but in extending Interfaces.
If you create an extension method for an interface, all classes that implement that interface will automatically gain that functionality.
This is the secret of LINQ. Methods like .Where(), .Select() or .First() are not defined in List<T> nor in Array. They are extension methods on the IEnumerable<T> interface.
Example: Let’s create a Print() method that works for any collection.
public static class CollectionExtensions
{
// We extend IEnumerable<T>, so it works for List, Array, HashSet, etc.
public static void Print<T>(this IEnumerable<T> coleccion)
{
Console.WriteLine("[" + string.Join(", ", coleccion) + "]");
}
}
// Usage
int[] numeros = { 1, 2, 3 };
List<string> nombres = new List<string> { "Luis", "Ana" };
numeros.Print(); // [1, 2, 3]
nombres.Print(); // [Luis, Ana]
Priority and conflicts
You might be wondering:
What happens if I create an extension method with the same name as a method that already exists in the class?
C# has a priority rule: Instance methods always win.
If the String class had a native ContarPalabras() method, our extension method would simply be ignored by the compiler, unless we call it explicitly in a static way.
Be careful not to “overwrite” future names. If Microsoft updates .NET and adds a method with the same name as your extension, your code will silently stop using your version and start using the native one (which might behave differently).
Null handling
Unlike normal instance methods, extension methods can be executed on null objects without immediately throwing an exception.
This happens because, remember, it’s actually a static call: StringExtensions.Metodo(null).
This allows us to create safe (“Null-safe”) check methods:
public static bool IsNullOrEmpty(this string str)
{
return string.IsNullOrEmpty(str);
}
// Usage
string texto = null;
bool vacio = texto.IsNullOrEmpty(); // Doesn't crash! Returns true.
If we had called texto.Length (an instance method), it would have thrown a NullReferenceException.
Practical examples
Extending the inttype
Suppose we want to add a method to the int type that returns whether a number is even:
public static class IntExtensions
{
public static bool EsPar(this int numero)
{
return numero % 2 == 0;
}
}
Usage:
int numero = 10;
if (numero.EsPar())
{
Console.WriteLine($"{numero} is even.");
}
Extending the List<T>type
We can add a method that returns the most common element in a list:
public static class ListExtensions
{
public static T ElementoMasComun<T>(this List<T> lista)
{
return lista.GroupBy(x => x)
.OrderByDescending(g => g.Count())
.First()
.Key;
}
}
Usage:
List<int> numeros = new List<int> { 1, 2, 2, 3, 3, 3, 4 };
int masComun = numeros.ElementoMasComun();
Console.WriteLine($"The most common number is: {masComun}");
Extending the DateTimetype
We can add a method that calculates age from a birth date:
public static class DateTimeExtensions
{
public static int CalcularEdad(this DateTime fechaNacimiento)
{
var hoy = DateTime.Today;
var edad = hoy.Year - fechaNacimiento.Year;
if (fechaNacimiento.Date > hoy.AddYears(-edad)) edad--;
return edad;
}
}
Usage:
DateTime fechaNacimiento = new DateTime(1990, 5, 15);
int edad = fechaNacimiento.CalcularEdad();
Console.WriteLine($"The age is: {edad} years.");
Extension method for IEnumerable<T>
Suppose we want to add a method that returns a string with all elements of a collection separated by a delimiter:
public static class EnumerableExtensions
{
public static string UnirConDelimitador<T>(this IEnumerable<T> coleccion, string delimitador)
{
return string.Join(delimitador, coleccion);
}
}
Usage:
List<string> nombres = new List<string> { "Alice", "Bob", "Charlie" };
string resultado = nombres.UnirConDelimitador(", ");
Console.WriteLine(resultado); // Output: Alice, Bob, Charlie
