Comprendre les méthodes et utiliser les méthodes d'extension C#

Méthodes d'instance définies

En C#, une méthode est définie au sein d'une classe. La syntaxe générale d'une définition de méthode comprend un modificateur d'accès, un type de retour, un nom de méthode et des paramètres.

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

Dans l'exemple de Tim Corey à 4:05, il définit une méthode dans une classe statique pour créer une méthode d'extension. La méthode définie est PrintToConsole. La définition comprend toute la syntaxe générale qui explique clairement comment définir une méthode à l'aide d'un exemple pratique :

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Appeler une méthode

Un "appel de méthode" indique au programme d'exécuter une méthode spécifique définie ailleurs dans le code, réalisant ainsi une action prédéfinie. Les méthodes sont appelées en utilisant l'instance de la classe, ou directement s'il s'agit de méthodes statiques. Les méthodes d'extension apparaissent comme si elles faisaient partie du type qu'elles étendent. Dans la vidéo à 6:18, Tim montre comment appeler une méthode d'extension avec un type de données primitif, tout comme ses méthodes prédéfinies.

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

Paramètres

Les paramètres sont spécifiés dans la définition de la méthode et servent d'espaces réservés pour les valeurs qui sont transmises à la méthode. Vous pouvez le voir ici après que la méthode WriteLine est appelée, où message est le paramètre.

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

Encore une fois, dans l'exemple de méthode d'extension que Tim Corey a donné à 4:05, message est le paramètre :

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

Arguments

Les arguments sont les valeurs réelles transmises à la méthode lorsqu'elle est appelée.

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

Quand Tim Corey appelle la méthode à 6:20 en utilisant la syntaxe point avec le type de chaîne, la valeur de la chaîne est effectivement passée en tant que valeur à la méthode PrintToConsole :

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

Qu'est-ce que les méthodes d'extension ? (3:13)

Les méthodes d'extension permettent d'ajouter de nouvelles méthodes à des types existants sans avoir à les modifier ou à les recompiler. Alors qu'elles sont appelées comme s'il s'agissait de méthodes d'instance, les méthodes d'extension sont définies comme statiques.

Création d'une méthode d'extension

Dans la section précédente, "Définition et appel de méthodes", nous avons montré comment Tim Corey a créé une méthode d'extension dans une classe statique distincte et a défini la méthode statique au sein de cette classe pour qu'elle soit utilisée comme méthode d'extension. Voici quelques points clés sur lesquels Tim Corey insiste :

1. Veillez à définir une classe statique publique distincte ou, comme le dit Tim, "marquez la classe comme statique, sinon elle ne fonctionnera pas"
2. Au fur et à mesure que vous créez des méthodes d'extension, regroupez-les par type (3:43)
3. Définissez une méthode statique avec le premier paramètre préfixé par le mot-clé this, spécifiant le type à étendre (4:58)

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Appeler la méthode d'extension (6:18)

Ensuite, Tim montre comment appeler une méthode d'extension sur cette variable de type chaîne :

demo.PrintToConsole();

demo.PrintToConsole();

Quand vous entrez demo et commencez à taper Print, IntelliSense suggère la méthode PrintToConsole. Ceci est la nouvelle méthode ajoutée au type string.

Comment fonctionne l'appel de méthode (6:30)

Tim explique pourquoi vous pouvez appeler demo.PrintToConsole() :

• Démo est un type String : La variable demo est de type string.
• Type de chaîne étendu : Le type string a été étendu avec la nouvelle méthode PrintToConsole.

Compréhension du paramètre (6:41)

Bien qu'il semble qu'aucun paramètre ne soit passé à la méthode PrintToConsole, Tim souligne le passage implicite de paramètres - la chaîne demo est passée comme le premier paramètre à la méthode d'extension.

Tim insiste sur le fait que les méthodes d'extension ont un paramètre de moins dans l'appel que dans leur définition. En effet, le premier paramètre (le type étendu) est implicite.

Signature de la méthode d'extension

Ici, this string message signifie que la méthode étend le type string, et message est le paramètre implicite :

public static void PrintToConsole(this string message)

public static void PrintToConsole(this string message)

Exécuter le code (7:08)

Enfin, lorsque la méthode PrintToConsole est appelée, elle affiche la chaîne dans la console :

Console.WriteLine(message);

Console.WriteLine(message);

Donc, appeler demo.PrintToConsole() imprime "Ceci est une démo" dans la console.

Extension de classes tierces (10:59)

Tim Corey explique que les méthodes d'extension peuvent étendre n'importe quel type, même les classes tierces que vous ne pouvez pas modifier directement. Par exemple, examinons la classe SimpleLogger à 11:09.

Ici, Tim utilise la classe hypothétique tierce SimpleLogger qui enregistre les messages dans la console (11:09). La classe comporte deux méthodes :

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

Ces méthodes ne sont pas idéales car le type de message est une simple chaîne de caractères, ce qui peut entraîner des incohérences. Tim suggère de créer des méthodes d'extension pour améliorer la classe.

Mise en œuvre de types de messages cohérents

L'utilisation de méthodes d'extension garantit la cohérence de votre code en utilisant toujours les mêmes types de messages et le même formatage. Ici à (12:40), Tim crée une classe statique ExtendSimpleLogger :

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }

    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

Rendre les appels plus cohérents

Avec cela en main, (14:02) il est maintenant capable d'appeler les méthodes d'extension sur une instance SimpleLogger :

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

Cela garantit que les types de messages sont toujours "Erreur" et "Avertissement".

Améliorer le formatage des sorties (14:35)

Tim ajoute une fonctionnalité permettant de définir la couleur du texte de la console pour les messages d'erreur, afin de s'assurer qu'ils sont bien visibles :

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

Comparaison avec les appels de méthode directs (17:21)

Tim compare cette approche à l'appel direct des méthodes originales Log, ce qui pourrait entraîner des incohérences :

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

Cette approche est sujette aux fautes de frappe et aux incohérences de formatage.

Chaîner les méthodes d'extension (18:13)

Tim montre comment les méthodes d'extension peuvent être enchaînées pour rendre le code plus lisible :

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

Vous pouvez maintenant enchaîner ces méthodes :

logger.LogInfo("Information").SaveToDatabase();

logger.LogInfo("Information").SaveToDatabase();

Cela rend le code plus lisible et plus intuitif par rapport aux appels de méthodes imbriqués :

SaveToDatabase(LogInfo(logger, "Information"));

SaveToDatabase(LogInfo(logger, "Information"));

En utilisant la notation par points et le chaînage, l'intention du code est plus claire et moins imbriquée.

Extension de choses que vous ne possédez pas

À 20:13, Tim Corey explique que les méthodes d'extension sont idéales pour ajouter des fonctionnalités à des classes que vous ne possédez pas, telles que des bibliothèques tierces. Cela permet d'apporter des améliorations sans modifier le code original.

Éviter les dépendances

Corey met également l'accent sur l'utilisation des méthodes d'extension pour introduire des dépendances sans les coupler directement à une classe. Par exemple, ajouter une fonctionnalité de sauvegarde dans une base de données à une classe Person sans y intégrer la logique de base de données.

Extension des interfaces

Les méthodes d'extension peuvent également s'appliquer aux interfaces, comme expliqué à partir de 21:30, ce qui permet à plusieurs classes qui mettent en œuvre l'interface de partager les mêmes fonctionnalités. Cela favorise la réutilisation et la simplification du code.

Quand ne pas utiliser les méthodes d'extension

À 23:03, Tim Corey conseille de ne pas abuser des méthodes d'extension, en particulier avec les types primitifs ou fournis par Microsoft, afin d'éviter l'encombrement et la complexité. Utilisez-les avec parcimonie et uniquement lorsqu'ils offrent des avantages évidents.

Le principe ouvert/fermé

Dans la section comprise entre 24:54 et 25:40, Tim insiste sur le respect du principe ouvert/fermé en utilisant des méthodes d'extension pour ajouter de nouvelles fonctionnalités sans modifier le code existant et stable, réduisant ainsi le risque d'introduire des bogues.

Bonnes pratiques pour l'utilisation des déclarations

Organisez les méthodes d'extension en les regroupant de manière logique et en les plaçant dans des espaces de noms distincts afin d'éviter les conflits de noms et de faciliter la maintenance et le débogage.