L'operatore lambda expression (=>) definisce un'espressione lambda

Il => token è supportato in due forme: come operatore lambda e come separatore di un nome del membro e dell'implementazione del membro in una definizione del corpo dell'espressione.

Il riferimento al linguaggio C# documenta la versione rilasciata più di recente del linguaggio C#. Contiene anche la documentazione iniziale per le funzionalità nelle versioni di anteprima pubblica per la prossima versione del linguaggio di programmazione.

La documentazione identifica tutte le funzionalità introdotte nelle ultime tre versioni della lingua o nelle anteprime pubbliche correnti.

Suggerimento

Per trovare quando una funzionalità è stata introdotta per la prima volta in C#, vedere l'articolo sulla cronologia delle versioni del linguaggio C#.

Operatore lambda

Nelle espressioni lambda, l'operatore => lambda separa i parametri di input sul lato sinistro dal corpo lambda a destra.

Nell'esempio seguente viene usata la funzionalità LINQ con la sintassi del metodo per illustrare l'utilizzo delle espressioni 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

I parametri di input di un'espressione lambda sono fortemente tipizzati durante la compilazione. Quando il compilatore deduce i tipi di parametri di input, come nell'esempio precedente, è possibile omettere dichiarazioni di tipo. Se è necessario specificare il tipo di parametri di input, è necessario specificare il tipo per ogni parametro, come illustrato nell'esempio seguente:

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

L'esempio seguente illustra come definire un'espressione lambda senza parametri di input:

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

Per altre informazioni, vedere Espressioni lambda.

Definizione del corpo dell'espressione

Una definizione del corpo dell'espressione usa la sintassi generale seguente:

member => expression;

Per un membro che restituisce un valore, il risultato dell'espressione deve essere convertibile in modo implicito nel tipo restituito del membro. Per un membro, un costruttore, un void finalizzatore o set, addinit, o remove una funzione di accesso, il corpo deve essere un'espressione di istruzione. Un'espressione di istruzione può essere un'assegnazione, una chiamata al metodo, la creazione di oggetti, l'operazione di incremento o decremento o await un'espressione. Il risultato, se disponibile, viene rimosso.

L'esempio seguente mostra una definizione del corpo dell'espressione per un Person.ToString metodo:

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

Si tratta di una versione abbreviata della definizione del metodo seguente:

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

È possibile usare le definizioni del corpo dell'espressione per i membri seguenti:

  • Metodi e funzioni locali: Un membro che restituisce un valore ha il formato T M() => expression;. Un void membro ha il formato void M() => statementExpression;. Per altre informazioni, vedere Metodi e funzioni locali.
  • Operatori: Un operatore ha il formato public static T operator +(T left, T right) => expression;. Per altre informazioni, vedere Sovraccarico degli operatori.
  • Proprietà e indicizzatori: Una proprietà di sola lettura o un indicizzatore ha il formato T P => expression; o T this[int i] => expression;. È anche possibile usare i corpi delle espressioni per le singole funzioni di accesso. Una get funzione di accesso ha il formato get => expression;. Una set funzione di accesso o init ha il formato set => statementExpression; o init => statementExpression;. Per altre informazioni, vedere Proprietà e indicizzatori.
  • Costruttori e finalizzatori: Questi membri hanno il formato C() => statementExpression; o ~C() => statementExpression;. Per altre informazioni, vedere Costruttori e finalizzatori.
  • Funzioni di accesso agli eventi: Una add funzione di accesso o remove ha il formato add => statementExpression; o remove => statementExpression;. Per altre informazioni, vedere Events.

Sovraccarico degli operatori

Non è possibile eseguire l'overload dell'operatore => .

Specifiche del linguaggio C#

Per altre informazioni sull'operatore lambda, vedere la sezione Espressioni di funzione anonima della specifica del linguaggio C#.

Vedere anche

  • Last updated on