Découvrir les délégués et les expressions lambda

Les expressions lambda peuvent être directement affectées à des delegate. Exemple :

Un delegate est un type qui contient des références vers des méthodes possédant une signature spécifique. Les delegate permettent de transmettre des méthodes comme paramètres ou de leur affecter une référence de manière dynamique.

Exemple : Les delegate sont souvent utilisés pour les rappels et la gestion des événements.

Vous pouvez définir un delegate à l’aide du mot-clé delegate. Exemple :

Point clé : Les delegate permettent d’encapsuler des méthodes.

using System;

class Program {
    // Define a delegate
    public delegate void PrintDelegate(string message);

    static void Main() {
        PrintDelegate print = PrintMessage; // Assign method to delegate
        print("Hello, Delegates!"); // Call the method via the delegate
    }

    static void PrintMessage(string message) {
        Console.WriteLine(message);
    }
}

Une expression lambda est une manière concise de représenter une méthode anonyme en C#. Elle utilise la syntaxe (parameters) => expression.

Exemple : (x, y) => x + y représente une méthode qui additionne deux nombres.

Astuce : Les expressions lambda sont souvent utilisées avec LINQ et les delegate pour gagner en concision et en clarté.

Utiliser des expressions lambda avec des delegate

Les expressions lambda peuvent être directement affectées à des delegate. Exemple :

Point clé : Les expressions lambda rendent votre code plus concis et plus lisible.

using System;

class Program {
    public delegate int MathOperation(int x, int y);

    static void Main() {
        MathOperation add = (x, y) => x + y; // Lambda for addition
        Console.WriteLine("Result: " + add(10, 20)); // Outputs: Result: 30
    }
}

Un delegate unique peut référencer plusieurs méthodes. Toutes les méthodes sont appelées dans l’ordre. Exemple :

using System;

class Program {
    public delegate void Notify(string message);

    static void Main() {
        Notify notify = PrintMessage;
        notify += LogMessage;

        notify("Hello, Multicast Delegates!"); // Calls both methods
    }

    static void PrintMessage(string message) {
        Console.WriteLine("Print: " + message);
    }

    static void LogMessage(string message) {
        Console.WriteLine("Log: " + message);
    }
}

Créez un programme qui utilise un delegate StringOperation pour effectuer des manipulations de chaînes, comme la conversion en majuscules et l’inversion d’une chaîne. Exemple :

using System;

class Program {
    public delegate string StringOperation(string input);

    static void Main() {
        StringOperation operations = ToUpperCase;
        operations += ReverseString;

        string input = "Hello";
        foreach (var operation in operations.GetInvocationList()) {
            Console.WriteLine(((StringOperation)operation)(input));
        }
    }

    static string ToUpperCase(string input) {
        return input.ToUpper();
    }

    static string ReverseString(string input) {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}

Voici quelques bonnes pratiques :

• Utilisez des delegate pour implémenter les rappels et la gestion des événements.
• Préférez les expressions lambda pour obtenir un code concis et clair.
• Associez les expressions lambda à LINQ pour traiter efficacement les données.
• Évitez les expressions lambda excessivement complexes afin de préserver la lisibilité.

Astuce : Utilisez des noms de paramètres explicites dans les expressions lambda pour améliorer la clarté du code.

Félicitations ! Vous avez appris à utiliser les delegate et les expressions lambda pour écrire du code fonctionnel et piloté par les événements en C#. Dans la prochaine leçon, nous explorerons la réflexion en C#, une fonctionnalité puissante pour analyser les types lors de l’exécution. Continuons à coder !