Opérateur >= (référence C#)=> operator (C# reference)

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.The => token is supported in two forms: as the lambda operator and as a separator of a member name and the member implementation in an expression body definition.

Opérateur lamdbaLambda operator

Dans les expressions lambda, l’opérateur lambda => sépare les variables d’entrée du côté gauche et le corps lambda du côté droit.In lambda expressions, the lambda operator => separates the input variables on the left side from the lambda body on the right side.

L’exemple suivant utilise la fonctionnalité LINQ avec la syntaxe de méthode pour illustrer l’utilisation d’expressions lambda :The following example uses the LINQ feature with method syntax to demonstrate the usage of lambda expressions:

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

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

Les variables d’entrée des expressions lambda sont fortement typées au moment de la compilation.Input variables of lambda expressions are strongly typed at compile time. Quand le compilateur peut déduire les types des variables d’entrée, comme dans l’exemple précédent, vous pouvez omettre les déclarations de type.When the compiler can infer the types of input variables, like in the preceding example, you may omit type declarations. Si vous avez besoin de spécifier le type des variables d’entrée, vous devez le faire pour chaque variable, comme le montre l’exemple suivant :If you need to specify the type of input variables, you must do that for each variable, as the following example shows:

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

L’exemple suivant illustre comment définir une expression lambda sans variable d’entrée :The following example shows how to define a lambda expression without input variables:

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

Pour plus d’informations, consultez Expressions lambda.For more information, see Lambda expressions.

Définition de corps d’expressionExpression body definition

La syntaxe générale d’une définition de corps d’expression est la suivante :An expression body definition has the following general syntax:

member => expression;

expression est une expression valide.where expression is a valid expression. Le type de retour de expression doit être implicitement convertible en type de retour du membre.The return type of expression must be implicitly convertible to the member's return type. Si le type de retour du membre est void ou si le membre est un constructeur, un finaliseur ou un accesseur set de propriété, expression doit être une expression de déclaration : elle peut alors être de n’importe quel type.If the member's return type is void or if the member is a constructor, a finalizer, or a property set accessor, expression must be a statement expression; it can be of any type then.

L’exemple suivant montre une définition de corps d’expression pour une méthode Person.ToString :The following example shows an expression body definition for a Person.ToString method:

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

Il s’agit d’une version raccourcie de la définition de méthode suivante :It's a shorthand version of the following method definition:

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

Les définitions de corps d’expression pour les méthodes et les propriétés en lecture seule sont prises en charge à compter de C# 6.Expression body definitions for methods and read-only properties are supported starting with C# 6. Les définitions de corps d’expression pour les constructeurs, les finaliseurs, les accesseurs de propriétés et les indexeurs sont prises en charge à compter de C# 7.0.Expression body definitions for constructors, finalizers, property accessors, and indexers are supported starting with C# 7.0.

Pour plus d’informations, consultez Membres expression-bodied.For more information, see Expression-bodied members.

Capacité de surcharge de l’opérateurOperator overloadability

L’opérateur => ne peut pas être surchargé.The => operator cannot be overloaded.

spécification du langage C#C# language specification

Pour plus d’informations, consultez la section Expressions de fonction anonyme de la spécification du langage C#.For more information, see the Anonymous function expressions section of the C# language specification.

Voir aussiSee also