Condividi tramite

Operatore delegate

  • Articolo

L'operatore delegate crea un metodo anonimo che può essere convertito in un tipo delegato. Un metodo anonimo può essere convertito in tipi come System.Action e System.Func<TResult> utilizzati come argomenti in molti metodi.

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

Nota

Le espressioni lambda forniscono un modo più conciso ed espressivo per creare una funzione anonima. Usare l'operatore => per costruire un'espressione lambda:

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

Per altre informazioni sulle funzionalità delle espressioni lambda, ad esempio l'acquisizione di variabili esterne, vedere Espressioni lambda.

Quando si usa l'operatore delegate, è possibile omettere l'elenco di parametri. In tal caso, il metodo anonimo creato può essere convertito in un tipo delegato con qualsiasi elenco di parametri, come illustrato nell'esempio seguente:

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!

Questa è l'unica funzionalità di metodi anonimi non supportata dalle espressioni lambda. In tutti gli altri casi, un'espressione lambda è la modalità preferita per scrivere codice inline. È possibile usare le variabili discard per specificare due o più parametri di input di un metodo anonimo che non vengono usati dal metodo:

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

Per la compatibilità con le versioni precedenti, se solo un singolo parametro è denominato _, _ viene considerato come il nome di tale parametro all'interno di un metodo anonimo.

È possibile usare il modificatore static nella dichiarazione di un metodo anonimo:

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

Un metodo anonimo statico non può acquisire variabili locali o lo stato dell'istanza dall'inclusione di ambiti.

È anche possibile usare la parola chiave delegate per dichiarare un tipo delegato.

A partire da C# 11, il compilatore può memorizzare nella cache l'oggetto delegato creato da un gruppo di metodi. Si consideri il metodo seguente:

static void StaticFunction() { }

Quando si assegna il gruppo di metodi a un delegato, il compilatore memorizza nella cache il delegato:

Action a = StaticFunction;

Prima di C# 11, era necessario usare un'espressione lambda per riutilizzare un singolo oggetto delegato:

Action a = () => StaticFunction();

Specifiche del linguaggio C#

Per altre informazioni, vedere la sezione Espressioni di funzioni anonime della specifica del linguaggio C#.

Vedi anche