Partager via

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.

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 peut déduire 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 le faire pour 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 a la syntaxe générale suivante :

member => expression;

Où expression est une expression valide. Le type de retour de expression doit être implicitement convertible en type de retour du membre. Si le membre :

  • A un type de retour void ou
  • Il s'agit d'un :
    • Constructeur
    • Finaliseur
    • Accesseur de propriété ou d’indexeur set

expression doit être une expression d’instruction. Étant donné que le résultat de l’expression est ignoré, le type de retour de cette expression peut être n’importe quel type.

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 créer des définitions de corps d’expression pour les méthodes, les opérateurs, les propriétés en lecture seule, les constructeurs, les finaliseurs et les accesseurs de propriété et d’indexeur. Pour plus d’informations, consultez Membres expression-bodied.

Surcharge des opérateurs

L’opérateur => ne peut pas être surchargé.

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