Espressioni lambda e delegati per il confronto

1. Introduzione

Immagina di avere una lista di studenti e di doverli ordinare una volta per età, poi per cognome, poi per media dei voti, ma solo per chi ha passato tutti gli esami. Se per ogni confronto "una tantum" scrivi una nuova classe che implementa IComparer<T>, il tuo progetto diventerà presto una discarica di piccole classi comparatori. Non è comodo: il codice diventa pesante e poco leggibile.

Per queste situazioni, C# offre una soluzione più elegante: la possibilità di passare la logica di confronto direttamente al metodo Sort senza creare una classe separata.

Per questo ci servono i delegati e i loro fratelli compatti – le espressioni lambda.

I delegati – i nostri aiutanti flessibili

Prima di passare alle lambda, vediamo cos'è un delegato. In parole semplici, un delegato è un tipo che rappresenta un riferimento a un metodo. Suona un po' metafisico, vero? Pensala così:

Immagina di avere una lista di cose da fare, e alcune di queste sono "istruzioni" o "ricette". Un delegato è come una variabile speciale che può contenere il riferimento a una di queste "ricette" (metodi). Poi, quando devi eseguire quella cosa, semplicemente chiami la variabile-delegato e lei "chiama" il metodo a cui punta.

In C#, i delegati vengono usati per creare callback (chiamare un metodo più tardi, di solito come reazione a un evento), gestire eventi (reagire ad azioni, tipo il click di un bottone) e, ovviamente, per passare metodi come argomenti ad altri metodi (così un metodo può chiamarne un altro), che è proprio quello che ci serve per l'ordinamento.

Il metodo List<T>.Sort() ha diverse overload (versioni), e una di queste accetta un delegato speciale chiamato Comparison<T>.

2. Il delegato Comparison<T>

Cos'è Comparison<T>?

Comparison<T> è un delegato integrato in .NET, pensato apposta per confrontare due oggetti dello stesso tipo T. La sua "ricetta" è questa: prende in ingresso due oggetti di tipo T (chiamiamoli x e y) e restituisce un intero (int):

• Numero negativo (tipo -1), se x è "minore" di y.
• Zero (0), se x è "uguale" a y.
• Numero positivo (tipo 1), se x è "maggiore" di y.

Queste sono proprio le regole che usano anche IComparable.CompareTo e IComparer.Compare. Quindi la logica è la stessa, solo che ora possiamo passarla come "variabile-metodo" invece che come classe separata.

Vediamo un esempio. Torniamo ai nostri studenti. Supponiamo di avere una classe Student:

public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public double AverageGrade { get; set; }

    public Student(string firstName, string lastName, int age, double averageGrade)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
        AverageGrade = averageGrade;
    }

    public void PrintInfo()
    {
        Console.WriteLine($"Studente: {FirstName} {LastName}, Età: {Age}, Voto: {AverageGrade:F2}");
    }
}

Ora, per ordinare la lista degli studenti per età usando un delegato, possiamo scrivere un metodo statico separato che rispetta la signature di Comparison<Student>:

public class Program
{
    // Metodo che rispetta la signature del delegato Comparison<Student>
    // Confronterà due studenti per età
    public static int CompareStudentsByAge(Student student1, Student student2)
    {
        // Usiamo il metodo integrato CompareTo per i numeri,
        // che restituisce -1, 0 o 1 a seconda del confronto.
        return student1.Age.CompareTo(student2.Age);
    }

    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Ivan", "Petrov", 20, 4.5),
            new Student("Maria", "Sidorova", 22, 4.8),
            new Student("Aleksei", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2) // Due studenti con la stessa età
        };

        Console.WriteLine("--- Lista studenti prima dell'ordinamento ---");        
        foreach (var s in students)
            s.PrintInfo();

        Console.WriteLine("--- Ordiniamo gli studenti per età (usando il delegato) ---");
        students.Sort(CompareStudentsByAge); //passiamo il metodo CompareStudentsByAge come parametro

        foreach (var s in students)
            s.PrintInfo();
    }
}

Analizziamo il codice:

1. Abbiamo creato un metodo statico CompareStudentsByAge che prende due studenti e restituisce un int, seguendo il contratto di Comparison<Student>.
2. In Main abbiamo creato una lista di studenti.
3. Quando chiamiamo students.Sort(CompareStudentsByAge);, non chiamiamo subito il metodo CompareStudentsByAge()! Passiamo solo il riferimento a quel metodo. List<T>.Sort() poi chiamerà il nostro metodo CompareStudentsByAge tutte le volte che gli serve per ordinare, passando ogni volta coppie diverse di studenti. È come dare a qualcuno l'indirizzo di consegna, invece di spedire subito tutto il camion.

Questo approccio è molto più comodo che creare una classe comparatore separata per ogni piccolo ordinamento. Ma si può andare ancora oltre!

3. Ecco le Espressioni Lambda

Anche dover scrivere un metodo separato come CompareStudentsByAge può sembrare troppo, se la logica di confronto è semplice e serve solo una o due volte. Per queste situazioni in C# sono state introdotte le espressioni lambda (lambda expressions).

Cos'è un'espressione lambda? In pratica è un metodo anonimo o, come mi piace scherzare, un "metodo senza casa". È un modo per scrivere un pezzetto di codice (metodo) proprio dove serve, senza dichiararlo a parte. È come scrivere una nota veloce su un post-it e attaccarla direttamente al compito, invece di scrivere un intero manuale.

L'operatore principale delle espressioni lambda è => (si legge "freccia" o "va a"). Divide i parametri di ingresso dal corpo del metodo.

Sintassi base dell'espressione lambda

Supponiamo di avere un delegato (riferimento a un metodo) e di passarlo alla funzione Sort():

public static int CompareStudentsByAge(Student student1, Student student2)
{
   return student1.Age.CompareTo(student2.Age);
}

students.Sort(CompareStudentsByAge); //passiamo il metodo CompareStudentsByAge come parametro

C'è un modo per scriverlo più corto:

//passiamo un metodo anonimo come parametro
students.Sort( (Student student1, Student student2) => student1.Age.CompareTo(student2.Age) );

Qui invece del nome del metodo mettiamo le sue due cose più importanti:

• parametri: (Student student1, Student student2)
• contenuto del metodo: student1.Age.CompareTo(student2.Age)

Questa scrittura compatta del metodo si chiama espressione lambda: (parametri) => espressione

Come funziona

Il compilatore C# quando trova nel codice un'espressione lambda, genera un vero metodo da essa.

Supponiamo di avere questo codice:

students.Sort( (s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade) );

Il risultato della compilazione sarà più o meno così:

public static int CompareStudents_Lambda123(Student s1, Student s2)
{
   return s2.AverageGrade.CompareTo(s1.AverageGrade);
}

students.Sort( CompareStudents_Lambda123 );

4. Esempio di ordinamento ed espressioni lambda

Riscriviamo il nostro esempio con gli studenti usando un'espressione lambda:

public class Program
{
    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Ivan", "Petrov", 20, 4.5),
            new Student("Maria", "Sidorova", 22, 4.8),
            new Student("Aleksei", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2)
        };

        Console.WriteLine("--- Lista studenti prima dell'ordinamento ---");        
        foreach (var s in students)
            s.PrintInfo();

        // Ora la logica di confronto è scritta proprio qui, "sul posto"
        Console.WriteLine("--- Ordiniamo gli studenti per età (usando lambda) ---");
        students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));

        foreach (var s in students)
            s.PrintInfo();

        // Per ordinare in ordine decrescente, basta moltiplicare il risultato per -1
        Console.WriteLine("\n--- Ordiniamo gli studenti per media voti (decrescente) ---");
        // s2.CompareTo(s1) invece di s1.CompareTo(s2)
        students.Sort((s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade));

        foreach (var s in students)
            s.PrintInfo();
    }
}

Cosa è successo qui?

1. students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));
   • student1 e student2 sono i parametri che Sort passerà al nostro metodo anonimo (come x e y in Comparison<T>).
   • => è l'operatore lambda.
   • student1.Age.CompareTo(student2.Age) è il corpo della lambda. In questo caso è solo un'espressione, il cui risultato è il valore di ritorno.
2. Per ordinare per media voti in ordine decrescente abbiamo semplicemente invertito s1 e s2 in CompareTo. È il classico trucco per invertire l'ordine di ordinamento.

Perché è comodo?

• Compattezza: Non serve creare metodi o classi separati per ogni piccola logica di confronto.
• Leggibilità: La logica di confronto è proprio accanto alla chiamata di Sort(), il che rende il codice più chiaro, soprattutto nei casi semplici.
• Flessibilità: Puoi cambiare facilmente le condizioni di ordinamento "al volo".

5. Delegati e Lambda – la coppia perfetta

Potresti chiederti: quindi un'espressione lambda è la stessa cosa di un delegato, o è qualcos'altro?

In realtà, un'espressione lambda è solo syntactic sugar per creare un'istanza di un delegato o di un albero di espressioni (Expression Tree, ne parleremo più avanti). Quando il compilatore vede una lambda, "sotto il cofano" la trasforma in un'istanza del delegato giusto. Nel nostro caso, dato che List<T>.Sort() si aspetta un delegato Comparison<T>, il compilatore capisce che (student1, student2) => student1.Age.CompareTo(student2.Age) va trasformato proprio in Comparison<Student>.

Quindi, le lambda ci permettono di scrivere codice super conciso, e i delegati sono i "contenitori" che trasportano quel codice e lo fanno eseguire. Lavorano insieme!

Quando usare cosa?

• IComparable<T>: Usalo quando il tuo tipo ha un ordine naturale, ovvio di ordinamento. Per esempio, se ordini prodotti e il modo principale è per codice articolo. Questa interfaccia definisce l'ordine "di default".
• IComparer<T>: Usalo quando ti serve una logica di confronto riutilizzabile più volte, ma non vuoi "sporcare" la classe principale o quando hai diversi modi di ordinare. Per esempio, un IComparer per ordinare prodotti per prezzo, un altro per nome, e li usi in parti diverse del programma.
• Delegati (Comparison<T>) e Lambda: Perfetti per ordinamenti una tantum, ad-hoc, quando la logica di confronto è semplice e non serve una classe riutilizzabile. È il modo più comune e pulito per la maggior parte dei casi in C#. Inoltre è ottimo per passare logica ad altri metodi, tipo i metodi di filtro (Find, FindAll) o ricerca (FindIndex), che abbiamo visto prima.

someList.Sort()

someList.Sort(new MyComparer())

someList.Sort((x, y) => x.Prop.CompareTo(y.Prop))

6. Applicazione pratica e uno sguardo al futuro

Le espressioni lambda non sono solo "syntactic sugar" per l'ordinamento. Sono uno strumento potente, usato ovunque nel codice C# moderno. Le incontrerai spessissimo:

• In LINQ (Language Integrated Query): Questo è probabilmente l'uso più diffuso delle lambda. LINQ ti permette di scrivere query tipo SQL sulle collezioni, e le lambda servono per definire condizioni di filtro, ordinamento, proiezione dei dati. Presto studieremo LINQ e vedrai come le lambda lo rendono super potente e comodo.
• Nella gestione degli eventi: Le lambda permettono di descrivere in modo conciso cosa deve succedere a un certo evento (tipo il click di un bottone nell'interfaccia utente).
• Nella programmazione asincrona: Per definire i task che devono essere eseguiti in parallelo.
• In varie API .NET: Molti metodi della libreria standard .NET accettano delegati (e quindi lambda) come parametri per aggiungere logica flessibile.

Quindi, imparando le lambda, non solo migliori le tue skill di ordinamento, ma fai un grande passo verso la comprensione del codice e delle librerie C# moderne. È una skill che vale in ogni colloquio e ti servirà in ogni progetto!

7. Errori tipici e sfumature

Quando lavori con delegati e lambda per il confronto, ci sono alcune cose a cui fare attenzione:

Risultato di confronto sbagliato: Ricorda che CompareTo o la tua logica di confronto devono restituire un numero negativo, zero o positivo. Se per sbaglio restituisci altro, l'ordinamento potrebbe funzionare male o addirittura dare errori. L'errore più comune è quando i principianti restituiscono true o false invece di int. Il metodo Sort si aspetta proprio un risultato numerico, perché gli serve sapere non solo se gli elementi sono uguali, ma anche quale è "maggiore".

Gestione dei valori null: Se gli elementi nella tua collezione possono essere null, provare a chiamare un metodo su un oggetto null (tipo student1.Age.CompareTo(...) se student1 è null) causerà un NullReferenceException. In questi casi la tua logica di confronto deve gestire esplicitamente i valori null. Di solito, null è considerato "minore" di qualsiasi valore non null. Se entrambi sono null, sono uguali. Se uno è null e l'altro no, null è "minore".

// Esempio di gestione dei null in una lambda per il confronto
students.Sort((s1, s2) => {
    if (s1 == null && s2 == null) return 0;
    if (s1 == null) return -1; // null è minore di tutto
    if (s2 == null) return 1;  // non-null è maggiore di null
    return s1.Age.CompareTo(s2.Age); // Confrontiamo se entrambi non sono null
});

Per fortuna, nei progetti reali spesso le collezioni non contengono null, ma è importante ricordarselo!

Performance: Anche se le lambda sono super comode, a volte usarle troppo dentro cicli "caldi" o su collezioni enormi può avere un piccolo impatto sulle performance rispetto a IComparer ottimizzati e testati a fondo. Ma per la maggior parte dei casi la differenza è trascurabile, e il vantaggio in leggibilità e semplicità del codice è molto più importante.

Catene di confronti complesse: Come abbiamo visto nell'esempio di ordinamento per cognome e poi per nome, le lambda permettono di annidare più condizioni. È molto più comodo che scrivere dieci if in una riga! L'importante è sempre controllare prima il risultato del primo confronto (lastNameComparison != 0) e solo poi passare al livello successivo.

Le lambda e i delegati sono concetti fondamentali in C#, che aprono le porte a uno stile di programmazione più flessibile e funzionale. Capirli e saperli usare renderà il tuo codice molto più pulito, efficace e moderno. Continua a sperimentare, e presto li userai senza nemmeno pensarci!

2

Compito

C# SELF, livello 30, lezione 2

Bloccato

Ordinamento dei numeri usando un'espressione lambda

Ordinamento dei numeri usando un'espressione lambda

Apri