Les méthodes d'extension permettent d'ajouter des fonctionnalités à des types existants sans altérer leur code source ou créer de nouvelles classes dérivées. Ce mécanisme, intégré au langage C#, s'avère particulièrement utile pour enrichir des types comme string, DateTime ou des collections.

Prenons un cas concret : conversion d'une chaîne en entier. Traditionnellement, on implémenterait une méthode utilitaire :

public static int ConvertirEnEntier(string texte)
{
    if (int.TryParse(texte, out int resultat))
        return resultat;
    return -1; // Valeur par défaut en cas d'échec
}

L'utilisation nécessiterait un appel statique :

string valeur = "42";
int nombre = ConvertirEnEntier(valeur);

Avec une méthode d'extension, la syntaxe devient intuitive :

string valeur = "42";
int nombre = valeur.VersEntier();

Implémentation pratique

Créez une classe statique dans un projet dédié (ex: Outils.Extensions) :

using System;

namespace Outils.Extensions
{
    public static class TexteExtensions
    {
        /// <summary>
        /// Convertit une chaîne en entier avec gestion d'erreur
        /// </summary>
        /// <param name="source">Chaîne à convertir</param>
        /// <returns>Entier valide ou -1 si échec</returns>
        public static int VersEntier(this string source)
        {
            return int.TryParse(source, out int valeur) ? valeur : -1;
        }
    }
}

Les règles clés :

• La classe contaneur doit être static
• La méthode doit être déclarée static
• Le premier paramètre utilise le modificateur this suivi du type cible

Autre exemple : validation temporelle

Étendons DateTime avec une méthode vérifiant l'appartenance à un intervalle :

public static class DateExtensions
{
    /// <summary>
    /// Vérifie si une date est comprise entre deux bornes
    /// </summary>
    /// <param name="cible">Date à évaluer</param>
    /// <param name="debut">Limite inférieure</param>
    /// <param name="fin">Limite supérieure</param>
    /// <returns>true si dans l'intervalle, false sinon</returns>
    public static bool EstDansIntervalle(this DateTime cible, 
                                        DateTime debut, 
                                        DateTime fin)
    {
        return cible >= debut && cible <= fin;
    }
}

Utilisation simplifiée :

DateTime maintenant = DateTime.Now;
bool valide = maintenant.EstDansIntervalle(DateTime.Today, DateTime.Today.AddDays(7));

Conditions d'utilisation

Pour activer ces méthodes, référencez l'espace de noms dans votre fichier :

using Outils.Extensions;

Les méthodes d'extensino s'affichent automatiquement dans IntelliSense lorsque le namespace est importé. Notez qu'elles ne peuvent pas accéder aux membres privés du type étendu et ont une priorité inférieure aux méthodes natives du type.

Une bonne pratique consiste à organiser les méthodes par domaines fonctionnels (ex: TexteExtensions, DateExtensions) plutôt que de surcharger une seule classe. Ce pattern est massivement utilisé dans LINQ où des méthodes comme Where() ou Select() étendent IEnumerable<T>.