Espressioni Lambda in C#: Guida Completa

Le espressioni lambda in C# sono una caratteristica potente che consente di scrivere funzioni inline in modo conciso. Introdotte in C# 3.0, le espressioni lambda sono diventate fondamentali per lavorare con LINQ (Language Integrated Query) e altre funzionalità avanzate di C#. In questa guida, esploreremo cosa sono le espressioni lambda, la loro sintassi, e come utilizzarle per semplificare il codice.

Cos’è un’Espressione Lambda?

Un’espressione lambda è un modo conciso per scrivere un metodo anonimo (un metodo senza nome) in C#. Viene spesso utilizzata come argomento per metodi che richiedono delegati o per definire logica inline all’interno di metodi come Select, Where, OrderBy, e altri metodi LINQ.

Sintassi di Base

La sintassi di un’espressione lambda è composta da un elenco di parametri seguito da un operatore lambda =>, e infine un’espressione o un blocco di codice.

(parametri) => espressione

Esempio Semplice

Func<int, int> quadrato = x => x * x;
Console.WriteLine(quadrato(5));  // Output: 25

In questo esempio, x => x * x è un’espressione lambda che accetta un parametro x e restituisce x moltiplicato per x.

Utilizzo delle Espressioni Lambda

Le espressioni lambda possono essere utilizzate in diversi contesti, principalmente quando si lavora con delegati, LINQ, e metodi che accettano funzioni come parametri.

1. Espressioni Lambda con Delegati

Un’espressione lambda può essere assegnata a un delegato, che è un tipo di riferimento che rappresenta un metodo.

Esempio

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

In questo caso, (a, b) => a + b è un’espressione lambda che accetta due parametri a e b e restituisce la loro somma.

2. Espressioni Lambda con LINQ

Le espressioni lambda sono ampiamente utilizzate con LINQ per scrivere query in modo conciso e leggibile.

Esempio di LINQ con Where

int[] numeri = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var numeriPari = numeri.Where(n => n % 2 == 0);

foreach (var numero in numeriPari)
{
    Console.WriteLine(numero);  // Output: 2, 4, 6, 8, 10
}

In questo esempio, n => n % 2 == 0 è un’espressione lambda che filtra i numeri pari da un array.

3. Espressioni Lambda con Blocchi di Codice

Le espressioni lambda possono anche contenere blocchi di codice più complessi, non limitati a una singola espressione.

Esempio con Blocco di Codice

Func<int, int, int> differenza = (a, b) =>
{
    if (a > b)
        return a - b;
    else
        return b - a;
};

Console.WriteLine(differenza(7, 3));  // Output: 4
Console.WriteLine(differenza(3, 7));  // Output: 4

In questo esempio, l’espressione lambda contiene un blocco di codice che calcola la differenza assoluta tra due numeri.

Sintassi delle Espressioni Lambda

La sintassi delle espressioni lambda può variare a seconda del numero di parametri e della complessità dell’espressione.

1. Nessun Parametro

Un’espressione lambda può non avere parametri, in tal caso si usano le parentesi vuote.

Action saluta = () => Console.WriteLine("Ciao, mondo!");
saluta();  // Output: Ciao, mondo!

2. Un Singolo Parametro

Quando c’è un solo parametro, è possibile omettere le parentesi attorno ad esso.

Func<int, int> quadrato = x => x * x;
Console.WriteLine(quadrato(5));  // Output: 25

3. Più Parametri

Quando ci sono più parametri, devono essere racchiusi tra parentesi.

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

4. Nessun Valore di Ritorno

Quando l’espressione lambda non restituisce un valore, è possibile utilizzare Action o void come tipo di ritorno.

Action<string> stampaMessaggio = messaggio => Console.WriteLine(messaggio);
stampaMessaggio("Hello, Lambda!");  // Output: Hello, Lambda!

Espressioni Lambda Avanzate

1. Espressioni Lambda nelle Espressioni Expression

Le espressioni lambda possono essere rappresentate come oggetti Expression<TDelegate> per creare alberi di espressioni che possono essere analizzati, manipolati o convertiti in codice eseguibile.

Esempio

Expression<Func<int, int, int>> espressione = (a, b) => a + b;
Func<int, int, int> funzione = espressione.Compile();
Console.WriteLine(funzione(5, 3));  // Output: 8

2. Espressioni Lambda e Capturing

Le espressioni lambda possono catturare variabili dal contesto esterno. Questo si chiama closure.

Esempio

int fattore = 3;
Func<int, int> moltiplica = x => x * fattore;
Console.WriteLine(moltiplica(5));  // Output: 15

In questo esempio, la variabile fattore è catturata dall’espressione lambda.

Best Practices

1. Mantieni le Lambda Semplici

Evita di complicare troppo le espressioni lambda. Se una lambda diventa troppo complessa, considera l’estrazione della logica in un metodo separato.

2. Usa Espressioni Lambda dove Ha Senso

Le espressioni lambda sono più efficaci quando migliorano la leggibilità del codice. Non usarle eccessivamente in contesti in cui un metodo esplicito sarebbe più chiaro.

3. Considera le Prestazioni

Le espressioni lambda possono avere un leggero sovraccarico di runtime, specialmente se utilizzate con alberi di espressioni. Valuta l’impatto sulle prestazioni nei contesti critici.

Conclusione

Le espressioni lambda in C# offrono un modo potente e conciso per esprimere la logica inline, rendendo il codice più compatto e leggibile. Che tu stia lavorando con LINQ, delegati, o altre funzionalità avanzate, le espressioni lambda sono uno strumento essenziale nel tuo arsenale di programmazione C#. Con la comprensione delle varie sintassi e l’uso delle best practices, puoi sfruttare al massimo questa caratteristica per scrivere codice C# più efficiente ed elegante.