Partager via

Opérateur delegate

L’opérateur delegate crée une méthode anonyme qui peut être convertie en type délégué. Une méthode anonyme peut être convertie en types tels que System.Action les System.Func<TResult> types utilisés comme arguments en plusieurs méthodes.

Func<int, int, int> sum = delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(3, 4));  // output: 7

Remarque

Les expressions lambda fournissent un moyen plus concis et expressif de créer une fonction anonyme. Utilisez l’opérateur => pour construire une expression lambda :

Func<int, int, int> sum = (a, b) => a + b;
Console.WriteLine(sum(3, 4));  // output: 7

Pour plus d’informations sur les fonctionnalités des expressions lambda, par exemple, la capture de variables externes, consultez expressions lambda.

Lorsque vous utilisez l’opérateur delegate , vous pouvez omettre la liste des paramètres. Si vous le faites, la méthode anonyme créée peut être convertie en type délégué avec n’importe quelle liste de paramètres, comme l’illustre l’exemple suivant :

Action greet = delegate { Console.WriteLine("Hello!"); };
greet();

Action<int, double> introduce = delegate { Console.WriteLine("This is world!"); };
introduce(42, 2.7);

// Output:
// Hello!
// This is world!

C’est la seule fonctionnalité des méthodes anonymes qui n’est pas prise en charge par les expressions lambda. Dans tous les autres cas, une expression lambda est un moyen préféré d’écrire du code inline. Vous pouvez utiliser des abandons pour spécifier deux paramètres d’entrée ou plus d’une méthode anonyme qui ne sont pas utilisés par la méthode :

Func<int, int, int> constant = delegate (int _, int _) { return 42; };
Console.WriteLine(constant(3, 4));  // output: 42

Pour la compatibilité descendante, si un seul paramètre est nommé _, _ est traité comme le nom de ce paramètre dans une méthode anonyme.

Vous pouvez utiliser le static modificateur à la déclaration d’une méthode anonyme :

Func<int, int, int> sum = static delegate (int a, int b) { return a + b; };
Console.WriteLine(sum(10, 4));  // output: 14

Une méthode anonyme statique ne peut pas capturer les variables locales ou l’état de l’instance à partir d’étendues englobantes.

Vous utilisez également le delegate mot clé pour déclarer un type de délégué.

À compter de C# 11, le compilateur peut mettre en cache l’objet délégué créé à partir d’un groupe de méthodes. Considérez la méthode suivante :

static void StaticFunction() { }

Lorsque vous affectez le groupe de méthodes à un délégué, le compilateur met en cache le délégué :

Action a = StaticFunction;

Avant C# 11, vous devez utiliser une expression lambda pour réutiliser un objet délégué unique :

Action a = () => StaticFunction();

Spécification du langage C#

Pour plus d’informations, consultez la section Expressions de fonction anonyme de la spécification du langage C#.

Voir aussi