Délégués C#

Les délégués C# jouent un rôle important lorsque nous voulons gérer un événement ou un rappel dans notre code ou nous pouvons dire qu'une fonction ayant plus d'un paramètre d'un type de données différent mais que nous voulons transmettre une fonction elle-même plutôt qu'un paramètre . Dans ce cas, les délégués entrent en jeu car ils agissent comme un pointeur vers une fonction, puisqu'il s'agit d'un type de données de référence, il contient donc la référence de la méthode. Les délégués font partie de la classe System.Delegates en C#. Ils sont similaires à un pointeur de fonction en programmation C et C++.

Syntaxe

Jetons un coup d'œil à la syntaxe de déclaration des délégués en C #

<access modifier> delegate < return type > < delegate_name > ( <parameters>)

Explication : Dans la syntaxe ci-dessus, le modificateur d'accès doit être déclaré avant de déclarer les délégués, car il peut être public, privé ou protégé. Maintenant, pour déclarer un délégué, nous devons utiliser le mot-clé délégué suivi du type de retour de la fonction. Par exemple,

public delegate void Show ( char ch );

Le délégué show utilisé ci-dessus est utilisé pour pointer vers toute méthode ayant le même paramètre et le même type de retour associé à la fonction Show () .

Exemples d'implémentation de délégués C#

Voici les exemples mentionnésL

Exemple n°1

Code pour démontrer le fonctionnement des délégués à distribution unique :

Code :

using System;
class Singlecast_Delegates
{
public delegate void Delete_func() ;
public class SD
{
public static void text_display()
{
Console.WriteLine ( " Hey hello ! , How are you " ) ;
}
public static void text_show()
{
Console.WriteLine ( " Hi ! How is everything ? " ) ;
}
public void print()
{
Console.WriteLine ( " Print " ) ;
}
}
static void Main(string[] args)
{
Delete_func del_var1 = SD.text_show ;
Delete_func del_var2 = new Delete_func ( SD.text_display ) ;
SD obj = new SD() ;
Delete_func del_var3 = obj.print ;
del_var1() ;
del_var2() ;
del_var3() ;
Console.ReadLine () ;
}
}

Sortie :

Explication : Dans le code ci-dessus, vous pouvez voir que nous avons attribué la méthode statique text_show() de la classe SD pour déléguer Delete_func() puis nous avons attribué la méthode statique text_display() de la classe SD pour déléguer Delete_func () en utilisant le nouvel opérateur. De plus, nous pouvons utiliser les deux méthodes pour attribuer la fonction de délégué. Par conséquent, dans un premier temps, nous avons créé une instance de classe SD et attribué la méthode print() au délégué, ce qui signifie délégué avec classe. Au final, nous avons créé l'objet pour la classe SD afin de pouvoir appeler une à une les fonctions que nous avons créées dans notre code.

Exemple n°2

Code pour démontrer le fonctionnement des délégués en double casting :

Code :

using System ;
namespace Educba {
// Here we are declaring the class with name " Edu "
class Edu {
// In this class we will declare the delegates
// Here the return type and parameter type must be same as the return and parameter type
// of the 2 methods
// "number_addition" and "number_substraction" are 2 given delegate names by user
public delegate void number_addition ( int x , int y ) ;
public delegate void number_substraction ( int x , int y ) ;
// here we are declaring the "total" method
public void total ( int x , int y )
{
Console.WriteLine( " (50 + 10) = {0} " , x + y ) ;
}
// here we are declaring the "substraction" method
public void substraction ( int x , int y )
{
Console.WriteLine( " ( 95 - 30 ) = {0} ", x - y ) ;
}
// Main Method declaration
public static void Main(String []args)
{
// creating an object " obj " for "Edu"
Edu obj = new Edu() ;
number_addition delegate1 = new number_addition ( obj.total ) ;
number_substraction delegate2 = new number_substraction( obj.substraction ) ;
// creating an object of the delegate class named as " delegate1 "
// for method "total" and "delegate2" for method "substraction" &
// pass the parameter of the  2 methods by class object "obj"
// by instantiating the delegates
// passing the below values to the methods by declared delegate object
delegate1( 50 , 10) ;
delegate2( 95 , 30);
}
}
}

Sortie :

Explication : Dans le code ci-dessus, vous pouvez voir que nous utilisons des délégués à double diffusion, ce qui est différent des délégués à diffusion unique. Nous avons déclaré la classe avec le nom Edu et cette classe, nous avons déclaré deux délégués dont l'un est pour l'addition de deux entiers tandis que l'autre est pour la soustraction de 2 entiers donnés à la fois. Après cela, nous avons déclaré une méthode total pour stocker les résultats des délégués supplémentaires. De la même manière, nous avons déclaré une méthode supplémentaire pour stocker le résultat des délégués de soustraction. Dans la classe principale, nous créons l'objet de la classe Edu afin de pouvoir appeler les délégués pour effectuer des additions et des soustractions sur deux nombres entiers donnés. Nous transmettrons la valeur et obtiendrons les résultats.

Exemple #3

Code pour démontrer le fonctionnement des délégués anonymes :

Code :

using System;
// declaring delegate method Demo of void type
public delegate void Demo() ;
// creating a class for declaring a static method inside this class.
public class First_Program
{
static int Main()
{
Demo Display = delegate()
{  // displaying the output on the user screen
Console.WriteLine ( " Here is the Anonymous delegate method " ) ;
};
// Here we are calling the display function.
Display() ;
return 0 ;
}
}

Sortie :

Conclusion

chaque fois qu'un codeur a besoin de transmettre une méthode comme argument d'autres méthodes, nous utilisons des délégués ou nous pouvons dire que les délégués sont une classe à travers laquelle nous pouvons encapsuler une signature de fonction. Cela revient plus à donner un nom à un paramètre de méthode en C#.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!