Tutoriel C# de Base

Tutoriel C# Avancé

C# Orienté Objet (OOP)

Délégué (Delegate) C#

Que faire si nous voulons passer une fonction en tant que paramètre ? Comment C＃ traite-t-il les fonctions de rappel ou les gestionnaires d'événements ? La réponse est-délégué (delegate). Le délégué (Delegate) est une variable de type de référence qui contient une référence vers une méthode. La référence peut être modifiée au moment de l'exécution.

Les délégués sontDéfinir la signature de la méthodede type de données de référence. Vous pouvez définir une variable de délégué, comme d'autres types de données, qui peut référencer toute méthode ayant la même signature que le délégué.

Travailler avec un délégué implique trois étapes :

Déclaration de délégué
Définir la méthode cible
Appel du délégué

Il est possible de déclarer un délégué en utilisant la keyword delegate et la signature de la fonction, comme indiqué ci-dessous.

　 Syntaxe du délégué

[modificateur d'accès] delegate [type de retour] [nom du délégué]([paramètres])

Below est une déclaration d'un délégué nommé MyDelegate.

Exemple : Déclaration du délégué

public delegate void MyDelegate(string msg);

Above, we declared a MyDelegate withvoidRetour type et paramètre de chaîne. Le délégué peut être déclaré à l'extérieur ou à l'intérieur de la classe. En réalité, il devrait être déclaré à l'extérieur.

Après avoir déclaré le délégué, nous devons définir la méthode cible ou l'expression lambda. Nous pouvons créer un objet de délégué en utilisant la keyword new et passer une méthode dont le signature correspond à celle du délégué.

Exemple : Définir la méthode cible de l'attribut

public delegate void MyDelegate(string msg);　//　Déclaration de délégué
//Définir la méthode cible
MyDelegate del = new MyDelegate(MethodA);
//　Or
MyDelegate del = MethodA;　
//　ou expression lambda　
MyDelegate del = (string msg) => Console.WriteLine(msg);
//　Target method
static void MethodA(string message)
{
　　　　Console.WriteLine(message);
}

You can set the target method directly by assignment without creating an object of the delegate, for example MyDelegate del = MethodA.

After setting the target method, you can call the delegate using the Invoke() method or using the () operator.

Example: calling a delegate

del.Invoke("Hello World!");
//Or　
del("Hello World!");

The following is a complete example of a delegate.

Example: delegate

public delegate void MyDelegate(string msg);　//Déclaration de délégué
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyDelegate del = ClassA.MethodA;
　　　　　　　　del("Hello World");
　　　　　　　　del = ClassB.MethodB;
　　　　　　　　del("Hello World");
　　　　　　　　del = (string msg) => Console.WriteLine("Called lambda expression: ")　+　msg);
　　　　　　　　del("Hello World");
　　　　}
}
class ClassA
{
　　　　static void MethodA(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassA.MethodA() with parameter: ")　+　message);
　　　　}
}
class ClassB
{
　　　　static void MethodB(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassB.MethodB() with parameter: ")　+　message);
　　　　}
}

The following figure illustrates the delegate.

C# delegate

Passing a delegate as a parameter

Methods can have delegate type parameters, as shown below.

Example: delegate

public delegate void MyDelegate(string msg);　//Déclaration de délégué
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyDelegate del = ClassA.MethodA;
　　　　　　　　InvokeDelegate(del);
　　　　　　　　del = ClassB.MethodB;
　　　　　　　　InvokeDelegate(del);
　　　　　　　　del = (string msg) => Console.WriteLine("Called lambda expression: ")　+　msg);
　　　　　　　　InvokeDelegate(del);
　　　　}
　　　　static void InvokeDelegate(MyDelegate del)　//　MyDelegate type parameters
　　　　{
　　　　　　　　del("Hello World");
　　　　}
}
class ClassA
{
　　　　static void MethodA(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassA.MethodA() with parameter: ")　+　message);
　　　　}
}
class ClassB
{
　　　　static void MethodB(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassB.MethodB() with parameter: ")　+　message);
　　　　}
}

In .NET, Func and Action types are built-in generic delegates and should be used for the most common delegates instead of creating new custom delegates.

Multicast delegate

A delegate can point to multiple methods. A delegate that points to multiple methods is called a multicast delegate.+” ou “+The assignment operator adds a function to the call list, while "-" and "-The assignment operator removes it.

Example: multicast delegate

public delegate void MyDelegate(string msg);　//Declare a delegate
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyDelegate del1　= ClassA.MethodA;
　　　　　　　　MyDelegate del2　= ClassB.MethodB;
　　　　　　　　MyDelegate del = del1　+　del2;　//　del1　+　del2
　　　　　　　　del("Hello World");
　　　　　　　　MyDelegate del3　= (string msg) => Console.WriteLine("Called lambda expression: ")　+　msg);
　　　　　　　　del　+= del3;　//　del1　+　del2　+　del3
　　　　　　　　del("Hello World");
　　　　　　　　del = del　-　del2;　//　Remove del2
　　　　　　　　del("Hello World");
　　　　　　　　del　-= del1　//　Remove del1
　　　　　　　　del("Hello World");
　　　　}
}
class ClassA
{
　　　　static void MethodA(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassA.MethodA() with parameter: ")　+　message);
　　　　}
}
class ClassB
{
　　　　static void MethodB(string message)
　　　　{
　　　　　　　　Console.WriteLine("Called ClassB.MethodB() with parameter: ")　+　message);
　　　　}
}

Les opérateurs d'addition et de soustraction travaillent toujours comme partie d'une affectation : del1+=del2; et del1=del1+del2C'est également le cas pour la soustraction.

Si un délégué retourne une valeur, alors la valeur de la méthode cible assignée en dernier lors de l'appel d'un délégué multicast sera retournée.

Exemple : Délégués multicast retournant une valeur

public delegate int MyDelegate();　//Déclaration de délégué
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyDelegate del1　= ClassA.MethodA;
　　　　　　　　MyDelegate del2　= ClassB.MethodB;
　　　　　　　　MyDelegate del = del1　+　del2;　
　　　　　　　　Console.WriteLine(del());//　Retour200
　　　　}
}
class ClassA
{
　　　　static int MethodA()
　　　　{
　　　　　　　　return　100;
　　　　}
}
class ClassB
{
　　　　static int MethodB()
　　　　{
　　　　　　　　return　200;
　　　　}
}

Délégués génériques

Les délégués génériques peuvent être définis de la même manière que les délégués, mais peuvent utiliser des paramètres de type générique ou de type de retour. Lorsque vous définissez la méthode cible, vous devez spécifier le type générique.

Par exemple, regardez le délégué générique suivant utilisé pour les paramètres int et string.

Exemple : Délégués génériques

public delegate T add<T>(T param1, T param2;　//　Délégués génériques
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　add<int> sum = Sum;
　　　　　　　　Console.WriteLine(sum(10,　20));
　　　　　　　　add<string> con = Concat;
　　　　　　　　Console.WriteLine(conct("Hello ", "World!!"));
　　　　}
　　　　public static int Sum(int val1, int val2)
　　　　{
　　　　　　　　return val1　+　val2;
　　　　}
　　　　public static string Concat(string str1, string str2)
　　　　{
　　　　　　　　return str1　+　str2;
　　　　}
}

Les délégués sont également utilisés pour déclarer des événements et des méthodes anonymes.

　Points à retenir

Un délégué est un type de données de type de référence définissant une signature.
Les variables de type de délégué peuvent référencer toute méthode ayant la même signature que le délégué.
Syntaxe :[Accesseur] Délégué [TypeDeRetour] [NomDuDélégué]([Paramètres])([access modifier] delegate [return type] [delegate name]([parameters]))
La signature de la méthode cible doit correspondre à la signature du délégué.
Le délégué peut être appelé comme une fonction ordinaire ou par la méthode invoke().
Il est possible d'utiliser “ +” ou “ + L'opérateur = attribue plusieurs méthodes à un délégué et utilise “-” ou “-L'opérateur = le supprime. Il est appelé délégué multicast.
Si un délégué multicast retourne une valeur, elle est récupérée à partir de la dernière méthode cible allouée.
Le délégué est utilisé pour déclarer des événements et des méthodes anonymes en C#.

FileInfo C#Exception personnalisée C#