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

La traduction de l'article a été préparée spécialement pour les étudiants du cours "Développeur C #" .

---

Quels sont les événements en C #?

Un événement peut être utilisé pour fournir des notifications. Vous pouvez vous abonner à l'événement si vous avez besoin de ces notifications. Vous pouvez également créer vos propres événements qui vous informeront que quelque chose qui vous intéresse s'est produit. Le .NET Framework propose des types intégrés que vous pouvez utiliser pour créer des événements. À l'aide de délégués, d'expressions lambda et de méthodes anonymes, vous pouvez créer et utiliser des événements de manière pratique.

Comprendre les délégués en C #

En C #, les délégués forment les éléments de base des événements. Un délégué est un type qui définit la signature d'une méthode. Par exemple, en C ++, cela peut être fait à l'aide d'un pointeur de fonction. En C #, vous pouvez créer une instance d'un délégué qui pointe vers une autre méthode. Vous pouvez appeler cette méthode via l'instance déléguée.

Voici un exemple de déclaration d'un délégué et d'appel d'une méthode par son intermédiaire.

Utilisation d'un délégué en C #

}class Program { public delegate double MathDelegate(double value1, double value2); public static double Add(double value1, double value2) { return value1 + value2; } public static double Subtract(double value1, double value2) { return value1 - value2; } Console.ReadLine(); public static void Main() { MathDelegate mathDelegate = Add; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = Subtract; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 } 

Comme vous pouvez le voir, nous utilisons le mot clé delegate pour indiquer au compilateur que nous créons un type délégué.

Il est facile d'instancier des délégués avec la création automatique d'un nouveau type de délégué.

Vous pouvez également utiliser le nouveau mot clé pour créer un délégué.

MathDelegate mathDelegate = new MathDelegate(Add) ;

Un délégué instancié est un objet; Vous pouvez également l'utiliser et passer comme argument à d'autres méthodes.

Délégués de multidiffusion en C #

Une autre grande caractéristique des délégués est que vous pouvez les combiner ensemble. C'est ce qu'on appelle la multidiffusion. Vous pouvez utiliser l'opérateur + ou + = pour ajouter une autre méthode à la liste d'appels d'une instance de délégué existante. De même, vous pouvez également supprimer une méthode de la liste d'appels à l'aide de l'opérateur d'affectation de décrémentation (- ou - =). Cette fonctionnalité sert de base aux événements en C #. Voici un exemple de délégué de multidiffusion.

 class Program { static void Hello(string s) { Console.WriteLine(" Hello, {0}!", s); } static void Goodbye(string s) { Console.WriteLine(" Goodbye, {0}!", s); } delegate void Del(string s); static void Main() { Del a, b, c, d; //   a    Hello: a = Hello; //   b    Goodbye: b = Goodbye; //    a  b - c: c = a + b; //  a    c,   d,       Goodbye: d = c - a; Console.WriteLine("Invoking delegate a:"); a("A"); Console.WriteLine("Invoking delegate b:"); b("B"); Console.WriteLine("Invoking delegate c:"); c("C"); Console.WriteLine("Invoking delegate d:"); d("D"); /* : Invoking delegate a: Hello, A! Invoking delegate b: Goodbye, B! Invoking delegate c: Hello, C! Goodbye, C! Invoking delegate d: Goodbye, D! */ Console.ReadLine(); } } 

Cela est possible car les délégués héritent de la classe System.MulticastDelegate , qui à son tour hérite de System.Delegate . Vous pouvez utiliser les membres définis dans ces classes de base pour vos délégués.

Par exemple, pour savoir combien de méthodes un délégué de multidiffusion appellera, vous pouvez utiliser le code suivant:

 int invocationCount = d.GetInvocationList().GetLength(0); 

Covariance et contravariance en C #

Lorsque vous affectez une méthode à un délégué, la signature de la méthode ne doit pas nécessairement correspondre exactement au délégué. C'est ce qu'on appelle la covariance et la contravariance. La covariance permet à une méthode d'avoir un type de retour plus dérivé que celui défini dans le délégué. La contravariance permet une méthode avec des types de paramètres moins dérivés que les types du délégué.

Covariance des délégués

Voici un exemple de covariance,

 class Program { public delegate TextWriter CovarianceDel(); public static StreamWriter MethodStream() { return null; } public static StringWriter MethodString() { return null; } static void Main() { CovarianceDel del; del = MethodStream; del = MethodString; Console.ReadLine(); } } 

Étant donné que StreamWriter et StringWriter héritent de TextWriter , vous pouvez utiliser CovarianceDel avec les deux méthodes.

Contravariance chez les délégués

Ce qui suit est un exemple de contravariance.

 class Program { public static void DoSomething(TextWriter textWriter) { } public delegate void ContravarianceDel(StreamWriter streamWriter); static void Main() { ContravarianceDel del = DoSomething; Console.ReadLine(); } } 

Étant donné que la méthode DoSomething peut fonctionner avec TextWriter , elle peut certainement fonctionner avec StreamWriter . En raison de la contravariance, vous pouvez appeler un délégué et transmettre une instance de StreamWriter à la méthode DoSomething .

Vous pouvez en savoir plus sur ce concept ici .

Expressions lambda en C #

Parfois, une signature de méthode entière peut nécessiter plus de code que le corps de la méthode elle-même. Il existe également des situations dans lesquelles vous devez créer une méthode entière juste pour l'utiliser en tant que délégué.

Pour ces cas, Microsoft a ajouté de nouvelles fonctionnalités en C #, telles que des méthodes anonymes dans 2.0. En C # 3.0, les choses se sont encore améliorées lorsque des expressions lambda ont été ajoutées. L'expression lambda est la méthode préférée lors de l'écriture de nouveau code.

Voici un exemple de la dernière syntaxe lambda.

 class Program { public delegate double MathDelegate(double value1, double value2); public static void Main() { MathDelegate mathDelegate = (x,y) => x + y; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = (x, y) => x - y; ; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 Console.ReadLine(); } } 

Pour lire ce code, vous devez utiliser le mot «suit» dans le contexte de la syntaxe lambda spéciale. Par exemple, la première expression lambda dans l'exemple ci-dessus se lit «x et y suivent l'addition de x et y».

Une fonction lambda n'a pas de nom spécifique, contrairement à une méthode. Pour cette raison, les lambdas sont appelées fonctions anonymes. Vous n'avez également pas besoin de spécifier explicitement le type de la valeur de retour. Le compilateur l'assume automatiquement à partir de votre lambda. Et dans le cas de l'exemple ci-dessus, les types de paramètres x et y ne sont pas non plus explicitement spécifiés.

Vous pouvez créer des lambdas qui s'étendent sur plusieurs opérateurs. Vous pouvez le faire en ajoutant des accolades autour des instructions qui composent le lambda, comme indiqué dans l'exemple ci-dessous.

 MathDelegate mathDelegate = (x,y) => { Console.WriteLine("Add"); return x + y; }; 

Parfois, l'annonce d'un délégué pour un événement semble un peu lourde. Pour cette raison, le .NET Framework a plusieurs types de délégués intégrés que vous pouvez utiliser lors de la déclaration de délégués. Dans l'exemple MathDelegate, vous avez utilisé le délégué suivant:

 public delegate double MathDelegate(double value1, double value2); 

Vous pouvez remplacer ce délégué par l'un des types intégrés, à savoir Func <int, int, int> .

comme ça

 class Program { public static void Main() { Func<int, int, int> mathDelegate = (x,y) => { Console.WriteLine("Add"); return x + y; }; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = (x, y) => x - y; ; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 Console.ReadLine(); } } 

Les types Func <...> peuvent être trouvés dans l'espace de noms System. Ils représentent les délégués qui retournent un type et prennent de 0 à 16 paramètres. Tous ces types sont hérités de System.MulticaseDelegate afin que vous puissiez ajouter plusieurs méthodes à la liste d'appels.

Si vous avez besoin d'un type délégué qui ne renvoie pas de valeur, vous pouvez utiliser les types System.Action. Ils peuvent également prendre de 0 à 16 paramètres, mais ne renvoient pas de valeur.

Voici un exemple d'utilisation du type Action,

 class Program { public static void Main() { Action<int, int> mathDelegate = (x,y) => { Console.WriteLine(x + y); }; mathDelegate(5, 2); // : 7 mathDelegate = (x, y) => Console.WriteLine(x - y) ; mathDelegate(5, 2); // : 3 Console.ReadLine(); } } 

Vous pouvez en savoir plus sur les délégués intégrés .NET ici .

Les choses se compliquent lorsque votre fonction lambda commence à se référer à des variables déclarées en dehors de l'expression lambda ou à ceci. En règle générale, lorsqu'un contrôle quitte la portée d'une variable, la variable devient non valide. Mais que faire si le délégué fait référence à une variable locale. Pour résoudre ce problème, le compilateur génère du code qui prolonge la durée de vie de la variable capturée, au moins aussi longtemps que le délégué a la durée de vie la plus longue. C'est ce qu'on appelle une fermeture.

Vous pouvez en savoir plus sur les fermetures ici .

Événements en C #

Considérez un modèle de développement populaire - éditeur-abonné (pub / sub). Vous pouvez vous abonner à un événement, puis vous serez averti lorsque l'éditeur de l'événement lancera un nouvel événement. Ce système est utilisé pour établir une communication faible entre les composants d'une application.

Le délégué forme la base du système d'événements en C #.

Un événement est un type spécial de délégué qui facilite la programmation orientée événement. Les événements sont membres d'une classe qui ne peut pas être appelée en dehors de la classe, quel que soit le spécificateur d'accès. Ainsi, par exemple, un événement déclaré public permettrait aux autres classes d'utiliser + = et - = pour cet événement, mais le déclenchement d'un événement (c'est-à-dire l'appel d'un délégué) n'est autorisé que dans la classe contenant l'événement. Regardons un exemple,

 // -  Pub public class Pub { // OnChange    callback-  public event Action OnChange = delegate { }; public void Raise() { // OnChange OnChange(); } } 

Ensuite, une méthode d'une autre classe peut s'abonner à l'événement en ajoutant l'une de ses méthodes au délégué d'événement:

Voici un exemple montrant comment une classe peut fournir un délégué ouvert et générer un événement.

 class Program { static void Main(string[] args) { //   pub Pub p = new Pub(); //  Subscriber 1   OnChange p.OnChange += () => Console.WriteLine("Subscriber 1!"); //  Subscriber 2   OnChange p.OnChange += () => Console.WriteLine("Subscriber 2!"); //  p.Raise(); //   Raise()   callback-     Console.WriteLine("Press enter to terminate!"); Console.ReadLine(); } } 

Même si l'événement est déclaré public , il ne peut être déclenché directement ailleurs que dans la classe dans laquelle il se trouve.

En utilisant le mot-clé d' event , le compilateur protège notre champ contre les accès indésirables.

Et aussi

Il ne permet pas l'utilisation de = (affectation directe de délégué). Par conséquent, votre code est désormais protégé contre le risque de supprimer les abonnés précédents en utilisant = au lieu de + =.

En outre, vous remarquerez peut-être la syntaxe spéciale d'initialisation du champ OnChange pour un délégué vide, tel que delegate { } . Cela garantit que notre champ OnChange n'est jamais nul. Par conséquent, nous pouvons supprimer la vérification null avant d'appeler l'événement s'il n'y a aucun autre membre de classe qui le rend nul.

Lorsque vous exécutez le programme ci-dessus, votre code crée une nouvelle instance de Pub, s'abonne à l'événement de deux manières différentes et génère un événement en appelant p.Raise. La classe Pub n'est complètement au courant d'aucun des abonnés. Il génère juste un événement.

Vous pouvez également lire mon article, C # Publisher-Subscriber Design Pattern, pour une compréhension plus approfondie de ce concept.

Eh bien, c'est tout pour l'instant. J'espère que vous comprenez l'idée. Merci d'avoir lu le post. Veuillez me faire savoir s'il y a des erreurs ou des changements sont nécessaires dans les commentaires ci-dessous. Merci d'avance!

Liens utiles

www.c-sharpcorner.com/blogs/c-sharp-generic-delegates-func-action-and-predicate
docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance
https://web.archive.org/web/20150707082707/http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx