Délégués et Événements en C#

En C#, les délégués et les événements constituent la base de la programmation orientée événements. Un delegate est un type sûr qui peut référencer une méthode. Un event permet à une classe de signaler au monde extérieur qu’« une certaine action s’est produite ». Ces mécanismes permettent de construire des architectures faiblement couplées et d’exécuter des méthodes de manière dynamique.

Qu’est-ce qu’un Délégué ?

Un délégué conserve des références à des méthodes avec une signature spécifique (paramètres et type de retour). En d’autres termes, ce sont des « structures qui peuvent transporter des méthodes comme des variables ». Une seule variable déléguée peut référencer plusieurs méthodes et les invoquer au besoin.

// Définition d’un délégué
public delegate void Notify(string message);

class Program
{
    static void SendEmail(string message)
    {
        Console.WriteLine("E-mail envoyé : " + message);
    }

    static void SendSms(string message)
    {
        Console.WriteLine("SMS envoyé : " + message);
    }

    static void Main()
    {
        Notify notifyHandler;

        // Affecter une méthode au délégué
        notifyHandler = SendEmail;
        notifyHandler("La réunion est à 10h00.");

        // Attacher une autre méthode au même délégué (multicast)
        notifyHandler += SendSms;
        notifyHandler("Nouveau produit en ligne !");
    }
}

Dans cet exemple, le délégué notifyHandler appelle à la fois la méthode SendEmail et SendSms. Les délégués permettent de diriger dynamiquement les événements vers différentes méthodes.

Qu’est-ce qu’un Événement ?

Un événement est un mécanisme qui signale qu’une action s’est produite. Il est généralement basé sur un délégué. Le mot-clé event est utilisé pour la déclaration, et il ne peut être utilisé à l’extérieur qu’avec += (s’abonner) ou -= (se désabonner). Cela garantit que l’événement ne peut être déclenché qu’à l’intérieur de la classe, et non contrôlé de l’extérieur.

public class Button
{
    // Définition d’un événement (EventHandler est un type de délégué standard)
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Bouton cliqué !");
        // Déclencher l’événement
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // S’abonner à l’événement
        btn.Click += (s, e) => Console.WriteLine("Événement : le bouton a été cliqué.");

        btn.SimulateClick();
    }
}

Ici, la classe Button publie un événement Click. Le code abonné (expression lambda) s’exécute lorsque l’événement est déclenché. Cette approche est couramment utilisée dans les applications UI comme WinForms et WPF.

EventHandler et EventArgs

En C#, le délégué standard le plus utilisé pour les événements est EventHandler. Avec EventArgs ou des classes qui en dérivent, on peut transmettre des informations supplémentaires sur l’événement.

public class OrderEventArgs : EventArgs
{
    public int OrderId { get; }
    public decimal Amount { get; }

    public OrderEventArgs(int orderId, decimal amount)
    {
        OrderId = orderId;
        Amount = amount;
    }
}

public class OrderService
{
    public event EventHandler<OrderEventArgs>? OrderCreated;

    public void CreateOrder(int id, decimal amount)
    {
        Console.WriteLine($"Commande créée (ID={id}, Montant={amount})");

        // Déclencher l’événement
        OrderCreated?.Invoke(this, new OrderEventArgs(id, amount));
    }
}

class Program
{
    static void Main()
    {
        var service = new OrderService();

        service.OrderCreated += (s, e) =>
        {
            Console.WriteLine($"Notification : Commande reçue (#{e.OrderId}, {e.Amount} EUR)");
        };

        service.CreateOrder(101, 250m);
    }
}

Dans cet exemple, la classe OrderService déclenche l’événement OrderCreated lorsqu’une nouvelle commande est créée. Le code abonné reçoit les informations de commande via EventArgs.

Quand utiliser les Délégués et les Événements ?

• Délégués : Pour passer des méthodes en paramètres, créer des callbacks ou invoquer plusieurs méthodes.
• Événements : Pour annoncer des interactions utilisateur (clics de bouton, fermeture de formulaire, etc.) ou des changements d’état dans les processus métiers.

TL;DR

Articles connexes