Méthodes d'extension

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy. Leçon 39 sur 70.

Les méthodes d’extension vous permettent d’ajouter de nouvelles méthodes à des types existants sans modifier leur code source ni créer de classes dérivées. Elles apparaissent comme si elles étaient des méthodes natives du type, ce qui rend votre code plus lisible et intuitif.

Pour créer une méthode d’extension, définissez une méthode statique dans une classe statique, avec le premier paramètre précédé du mot-clé this :

public static class StringExtensions
{
    public static int WordCount(this string str)
    {
        return str.Split(' ').Length;
    }
}

Vous pouvez maintenant appeler cette méthode directement sur n’importe quelle chaîne :

string sentence = "Hello World Today";
int count = sentence.WordCount();  // 3

Le paramètre this string str indique au compilateur que cette méthode étend le type string. Lorsque vous appelez sentence.WordCount(), le compilateur le traduit en StringExtensions.WordCount(sentence) en arrière-plan.

Les méthodes d’extension peuvent également accepter des paramètres supplémentaires :

public static bool IsLongerThan(this string str, int length)
{
    return str.Length > length;
}

// Utilisation
bool result = "Hello".IsLongerThan(3);  // true

Cette technique est largement utilisée dans LINQ, où des méthodes comme Where() et Select() sont des méthodes d’extension sur IEnumerable. Les méthodes d’extension sont pratiques pour ajouter des fonctions utilitaires à des types que vous ne contrôlez pas, tout en gardant votre code propre et expressif.

Défi

Facile

Construisons un ensemble de méthodes d’extension utiles pour les entiers, qui ajoutent les fonctionnalités pratiques que vous vous attendez à trouver intégrées. Vous allez créer une classe statique contenant des méthodes d’extension qui peuvent être appelées directement sur n’importe quel entier, rendant votre code plus expressif et plus lisible.

Vous organiserez votre code sur deux fichiers :

IntExtensions.cs : créez une classe statique appelée IntExtensions dans l’espace de noms Utilities. Cette classe contiendra des méthodes d’extension qui enrichissent le type int :
- IsEven() - renvoie true si le nombre est pair, et false dans le cas contraire
- Square() - renvoie le nombre multiplié par lui-même
- IsInRange(int min, int max) - renvoie true si le nombre est compris entre min et max (inclus), et false dans le cas contraire
N’oubliez pas que les méthodes d’extension doivent être des méthodes statiques dans une classe statique, le premier paramètre utilisant le mot-clé this pour spécifier le type que vous étendez.
Program.cs : dans votre fichier principal, lisez un entier depuis l’entrée et démontrez les trois méthodes d’extension. Appelez chaque méthode directement sur l’entier comme s’il s’agissait d’une méthode intégrée, puis affichez les résultats.

Vous recevrez trois entrées :

Un nombre à tester (entier)
La valeur minimale pour la vérification de l’intervalle (entier)
La valeur maximale pour la vérification de l’intervalle (entier)

Affichez la sortie dans ce format :

Is {number} even? {True/False}
Square of {number}: {result}
Is {number} in range [{min}-{max}]? {True/False}

Par exemple, si les entrées sont 7, 5 et 10, la sortie doit être :

Is 7 even? False
Square of 7: 49
Is 7 in range [5-10]? True

Remarquez à quel point vous pouvez écrire naturellement number.IsEven() et number.Square() : les méthodes d’extension donnent l’impression d’avoir toujours fait partie du type entier !

Essayez vous-même

using System;
using Utilities;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées
        int number = Convert.ToInt32(Console.ReadLine());
        int min = Convert.ToInt32(Console.ReadLine());
        int max = Convert.ToInt32(Console.ReadLine());

        // TODO: Utilisez les méthodes d'extension sur 'number' et affichez les résultats
        // Appelez number.IsEven(), number.Square() et number.IsInRange(min, max)
        // Affichez au format :
        // {number} est-il pair ? {True/False}
        // Carré de {number} : {result}
        // {number} est-il dans la plage [{min}-{max}] ? {True/False}

    }
}