Méthodes d’extension en C#

En C#, les méthodes d’extension offrent un moyen d’ajouter de nouvelles méthodes aux classes ou structures existantes, sans modifier leur code source. Ces méthodes sont définies dans une classe static, et leur premier paramètre utilise le mot-clé this pour spécifier le type étendu. Les méthodes d’extension enrichissent les fonctionnalités tout en gardant les types d’origine intacts.

Syntaxe de base

Une méthode d’extension doit toujours être définie dans une classe static. Son premier paramètre est marqué avec this pour indiquer le type qu’elle étend.

// Définition d’une méthode d’extension
public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string? text)
    {
        return string.IsNullOrEmpty(text);
    }
}

class Program
{
    static void Main()
    {
        string s1 = null;
        string s2 = "Bonjour";

        Console.WriteLine(s1.IsNullOrEmpty()); // True
        Console.WriteLine(s2.IsNullOrEmpty()); // False
    }
}

Ici, la méthode IsNullOrEmpty est définie dans StringExtensions, mais elle peut être utilisée comme si elle faisait partie du type string.

Cas d’utilisation des méthodes d’extension

• Ajouter de nouvelles fonctions aux classes existantes (par ex. string, DateTime).
• Appeler des méthodes utilitaires avec une syntaxe plus naturelle.
• Faciliter l’écriture fluide (fluent) comme avec LINQ.

Exemples pratiques

Les méthodes d’extension rendent les opérations courantes plus lisibles et plus pratiques.

// Méthodes d’extension pour les entiers
public static class IntExtensions
{
    // Le nombre est-il pair ?
    public static bool IsEven(this int number) => number % 2 == 0;
    // Le nombre est-il impair ?
    public static bool IsOdd(this int number) => number % 2 != 0;
}

class Program
{
    static void Main()
    {
        int x = 10;
        Console.WriteLine(x.IsEven()); // True
        Console.WriteLine(x.IsOdd());  // False
    }
}

Ici, IsEven et IsOdd sont définis comme s’ils appartenaient au type int. Toute variable int peut utiliser ces méthodes directement.

// Méthode d’extension pour DateTime
public static class DateTimeExtensions
{
    // Vérifie si la date tombe un week-end
    public static bool IsWeekend(this DateTime dt)
        => dt.DayOfWeek == DayOfWeek.Saturday || dt.DayOfWeek == DayOfWeek.Sunday;
}

class Program
{
    static void Main()
    {
        DateTime today = DateTime.Now;
        Console.WriteLine(today.IsWeekend() ? "Week-end" : "Jour de semaine");
    }
}

LINQ et méthodes d’extension

Toutes les méthodes LINQ sont implémentées en tant que méthodes d’extension. Par exemple, Where, Select et OrderBy sont des méthodes d’extension écrites pour IEnumerable<T>.

var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// Where est en fait une méthode d’extension
var evens = numbers.Where(n => n % 2 == 0);

Console.WriteLine(string.Join(", ", evens)); // 2, 4, 6

Exemple : Manipulation de chaînes

Définissons des méthodes d’extension pour effectuer des vérifications et des transformations sur des textes.

public static class TextExtensions
{
    // Convertit une chaîne en format titre (chaque mot avec une majuscule)
    public static string ToTitleCase(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return string.Empty;

        return string.Join(" ",
            text.Split(' ', StringSplitOptions.RemoveEmptyEntries)
                .Select(w => char.ToUpper(w[0]) + w.Substring(1).ToLower()));
    }

    // Vérifie si une chaîne contient des chiffres
    public static bool ContainsDigit(this string text)
    {
        return text.Any(char.IsDigit);
    }
}

class Program
{
    static void Main()
    {
        string input = "bonjour monde 2025";

        Console.WriteLine(input.ToTitleCase());   // "Bonjour Monde 2025"
        Console.WriteLine(input.ContainsDigit()); // True
    }
}

Avantages

• Améliore la lisibilité du code grâce à une syntaxe naturelle.
• Permet de réutiliser des classes existantes sans en créer de nouvelles.
• Ajoute de nouvelles fonctionnalités sans modifier les types existants.
• Permet de regrouper les méthodes utilitaires en un seul endroit.

TL;DR

Articles connexes