L’opérateur d’expression lambda (=>) définit une expression lambda

Le jeton => est pris en charge sous deux formes : comme opérateur lambda, et comme séparateur d’un nom de membre et de l’implémentation de membre dans une définition de corps d’expression.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Opérateur lamdba

Dans les expressions lambda, l’opérateur => lambda sépare les paramètres d’entrée du côté gauche du corps lambda à droite.

L’exemple suivant utilise la fonctionnalité LINQ avec une syntaxe de méthode pour illustrer l’utilisation d’expressions lambda :

string[] words = { "bot", "apple", "apricot" };
int minimalLength = words
  .Where(w => w.StartsWith("a"))
  .Min(w => w.Length);
Console.WriteLine(minimalLength);   // output: 5

int[] numbers = { 4, 7, 10 };
int product = numbers.Aggregate(1, (interim, next) => interim * next);
Console.WriteLine(product);   // output: 280

Les paramètres d’entrée d’une expression lambda sont fortement typés au moment de la compilation. Lorsque le compilateur déduit les types de paramètres d’entrée, comme dans l’exemple précédent, vous pouvez omettre les déclarations de type. Si vous devez spécifier le type de paramètres d’entrée, vous devez spécifier le type de chaque paramètre, comme l’illustre l’exemple suivant :

int[] numbers = { 4, 7, 10 };
int product = numbers.Aggregate(1, (int interim, int next) => interim * next);
Console.WriteLine(product);   // output: 280

L’exemple suivant montre comment définir une expression lambda sans paramètres d’entrée :

Func<string> greet = () => "Hello, World!";
Console.WriteLine(greet());

Pour plus d’informations, consultez expressions lambda.

Définition de corps d’expression

Une définition de corps d’expression utilise la syntaxe générale suivante :

member => expression;

Pour un membre qui retourne une valeur, le résultat de l’expression doit être implicitement convertible en type de retour du membre. Pour un membre, un constructeur, un void finaliseur ou setun initaddremove accesseur, le corps doit être une expression d’instruction. Une expression d’instruction peut être une affectation, un appel de méthode, une création d’objet, une opération d’incrémentation ou de décrémentation ou await une expression. Son résultat, le cas échéant, est ignoré.

L’exemple suivant montre une définition de corps d’expression pour une Person.ToString méthode :

public override string ToString() => $"{fname} {lname}".Trim();

Il s’agit d’une version abrégée de la définition de méthode suivante :

public override string ToString()
{
   return $"{fname} {lname}".Trim();
}

Vous pouvez utiliser des définitions de corps d’expression pour les membres suivants :

  • Méthodes et fonctions locales : Un membre qui retourne une valeur a le formulaire T M() => expression;. Un void membre a le formulaire void M() => statementExpression;. Pour plus d’informations, consultez Méthodes et fonctions locales.
  • Opérateurs : Un opérateur a le formulaire public static T operator +(T left, T right) => expression;. Pour plus d’informations, consultez Surcharge des opérateurs.
  • Propriétés et indexeurs : Une propriété ou un indexeur en lecture seule a le formulaire T P => expression; ou T this[int i] => expression;. Vous pouvez également utiliser des corps d’expression pour les accesseurs individuels. Un get accesseur a le formulaire get => expression;. Un set ou init accesseur a le formulaire set => statementExpression; ou init => statementExpression;. Pour plus d’informations, consultez Propriétés et indexeurs.
  • Constructeurs et finaliseurs : Ces membres ont le formulaire C() => statementExpression; ou ~C() => statementExpression;. Pour plus d’informations, consultez Constructeurs et finaliseurs.
  • Accesseurs d’événements : Un add ou remove accesseur a le formulaire add => statementExpression; ou remove => statementExpression;. Pour plus d’informations, consultez Événements.

Surcharge des opérateurs

Vous ne pouvez pas surcharger l’opérateur => .

Spécification du langage C#

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

Voir aussi

  • Last updated on