Qu'est-ce que les délégués et les événements ?

Question

Accepted Answer

Un **délégué** est une référence type-safe à une méthode (comme un pointeur de fonction) — il vous permet de traiter les méthodes comme des données : les stocker, les passer en arguments et les invoquer. Les **événements** sont un modèle construit sur les délégués pour le modèle publish-subscribe (observer). Ils sont à la base des callbacks, de LINQ et de la programmation événementielle en C#. ## Délégués — les méthodes comme valeurs ```csharp // a delegate type defines a method signature public delegate int Operation(int a, int b); Operation add = (a, b) => a + b; // assign a method/lambda to it Operation multiply = (a, b) => a * b; int result = add(2, 3); // invoke → 5 // pass a delegate as an argument (higher-order function) int Apply(Operation op, int x, int y) => op(x, y); Apply(multiply, 4, 5); // 20 ``` Un délégué contient une référence à une méthode correspondant à sa signature, permettant aux méthodes d'être transmises et invoquées dynamiquement. ## Types de délégués intégrés (utilisez ceux-ci, pas des types personnalisés) ```csharp Func add = (a, b) => a + b; // Func — takes args, RETURNS a value Action log = msg => Console.WriteLine(msg); // Action — returns VOID Predicate isPositive = n => n > 0; // Predicate — returns bool // used heavily in LINQ and APIs: list.Where(x => x > 0).Select(x => x * 2); // lambdas are delegates ``` En C# moderne, vous utilisez généralement les **`Func<>`** intégrés (retourne une valeur), **`Action<>`** (retourne void) et `Predicate<>` plutôt que de déclarer des types de délégué personnalisés. Les lambdas (`x => ...`) créent des délégués — la base de LINQ. ## Événements — le modèle publish-subscribe ```csharp public class Button { public event EventHandler Clicked; // an EVENT (based on a delegate) public void Click() => Clicked?.Invoke(this, EventArgs.Empty); // raise it } var button = new Button(); button.Clicked += (sender, e) => Console.WriteLine("clicked!"); // SUBSCRIBE (+=) button.Clicked -= handler; // unsubscribe (-=) ``` Un **événement** encapsule un délégué pour fournir un pub-sub sécurisé : les abonnés enregistrent les gestionnaires avec `+=`, l'éditeur déclenche l'événement (`Invoke`), et tous les gestionnaires s'exécutent. Les événements limitent le code externe à uniquement l'abonnement/le désabonnement (pas le déclenchement ou l'effacement) — l'encapsulation pour le modèle observer. ## Pourquoi c'est important Les délégués et les événements sont des fonctionnalités C# importantes qui permettent de traiter les méthodes comme des données, les callbacks et la programmation événementielle — et les comprendre est précieux à la fois pour les utiliser et pour saisir comment une grande partie de C# et .NET fonctionne. Les **délégués** (références de méthode type-safe) sont la fondation : ils permettent aux méthodes d'être stockées, transmises et invoquées dynamiquement, ce qui sous-tend **LINQ** (les lambdas passées à `Where`/`Select` sont des délégués), les callbacks et la programmation de style fonctionnel. Savoir utiliser les types de délégué intégrés **`Func<>`/`Action<>`/`Predicate<>`** (plutôt que de déclarer des types personnalisés) est une connaissance pratique, quotidienne, puisqu'ils apparaissent partout dans le framework et c'est ainsi que vous passez du comportement à LINQ et à de nombreuses API. Les **événements** s'appuient sur les délégués pour implémenter le modèle publish-subscribe (observer) de manière sécurisée — c'est la façon dont C# gère les scénarios pilotés par événements (événements d'interface, notifications, communication découplée), avec `+=`/`-=` pour l'abonnement/le désabonnement. Comprendre les délégués (en particulier Func/Action et les lambdas, la base de LINQ), et les événements (le modèle pub-sub pour un code découplé et piloté par événements) est important pour travailler efficacement avec C#, puisque ces fonctionnalités sous-tendent LINQ, les callbacks et la gestion d'événements qui apparaissent constamment. Les maîtriser — en particulier reconnaître que les lambdas sont des délégués et comment ils activent LINQ et les modèles fonctionnels — est une connaissance fréquemment appliquée qui reflète une compréhension des capacités fonctionnelles de C# et du modèle piloté par événements, et c'est un sujet d'entretien courant.