Interfaccia IComparable<T>

1. Introduzione

Immagina di chiedere a un amico di sistemare dei libri sugli scaffali. Se sono libri con numeri sul dorso (1, 2, 3…), il tuo amico lo farà senza problemi: "Ok, 1 va prima di 2, 2 prima di 3". Questo è l'ordine naturale dei numeri (in ordine crescente). Allo stesso modo, se sono libri con titoli che iniziano per "A", "B", "C", li metterà in ordine alfabetico. Anche questo è un ordine "naturale" per le stringhe (ordine alfabetico).

Ma se invece sui dorsi ci sono solo i cognomi degli autori? E tu dici: "Mettili in ordine". Il tuo amico chiederà: "In che ordine? Per cognome? Per anno di pubblicazione? Per numero di pagine?" Ecco dove nasce il problema. Per le tue entità uniche non c'è un ordine naturale ovvio.

Stessa cosa in programmazione. Quando proviamo a ordinare una lista di interi List<int>, C# sa già come fare. Per List<string> va bene lo stesso, usa l'ordine lessicografico (alfabetico). Ma se abbiamo una List<Student>, dove ogni Student è un oggetto con nome, cognome, età, id e mille altre cose, C# si blocca. Non sa su quale campo confrontare due studenti. Per nome? Per ID? Per media voti? Questo è proprio il problema che abbiamo visto nella lezione "Ordinamento delle collezioni", quando List<T>.Sort() ha dato errore provando a ordinare una collezione di tipi custom.

Per risolvere questo rompicapo, dobbiamo dare a C# un'istruzione chiara su come confrontare i nostri oggetti. Per questo esiste l'interfaccia IComparable<T>.

2. Interfaccia IComparable<T>

Quindi, per insegnare ai nostri oggetti a "sapere" il loro posto rispetto ad altri oggetti dello stesso tipo, usiamo l'interfaccia IComparable<T>. È un contratto. Quando la tua classe o struct implementa questa interfaccia, è come dire al compilatore: "Ehi! I miei oggetti si possono confrontare tra loro e ti spiego come si fa."

Come funziona?

L'interfaccia IComparable<T> definisce un solo metodo:

public interface IComparable<in T>
{
    int CompareTo(T other);
}

Questo metodo prende un oggetto di tipo T (lo stesso tipo dell'oggetto corrente) e deve restituire:

• un numero negativo (< 0) se l'oggetto corrente è "minore" di quello confrontato;
• zero (0) se sono "uguali" (dal punto di vista dell'ordinamento);
• un numero positivo (> 0) se l'oggetto corrente è "maggiore".

In pratica, è come i giudici in una gara, tipo in un incontro di boxe: se hai fatto meglio, vinci il round e prendi più punti; se peggio — meno; se il match è pari, il punteggio è uguale. Solo che qui invece dei giudici è ancora più semplice: un numero con segno.

Perché proprio così?

I metodi di ordinamento (tipo List<T>.Sort()) chiamano CompareTo sugli elementi della lista per capire chi mettere prima e chi dopo. Se la tua classe implementa questa interfaccia — la puoi ordinare!

3. Pratica

Supponiamo di avere una classe utente (User):

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Proviamo a ordinare una lista di utenti:

List<User> users = new List<User>
{
    new User { Name = "Sergey", Age = 31 },
    new User { Name = "Maria", Age = 22 },
    new User { Name = "Anton", Age = 27 }
};

users.Sort(); // BOOM! InvalidOperationException

Appare un errore: "Almeno un oggetto deve implementare IComparable" (Almeno un oggetto deve implementare IComparable).

Correggiamo: implementiamo IComparable<User>

Aggiungiamo l'interfaccia alla nostra classe. Facciamo che l'ordinamento sia per età — dai più giovani ai più vecchi:

public class User : IComparable<User>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public int CompareTo(User other)
    {
        // Protezione dagli errori: se other == null, il nostro utente è "maggiore"
        if (other == null) return 1;
        return this.Age.CompareTo(other.Age); // ordiniamo per età
    }
}

Ora creiamo la lista, chiamiamo users.Sort(); e stampiamo il risultato in console:

List<User> users = new List<User>
{
    new User { Name = "Sergey", Age = 31 },
    new User { Name = "Maria", Age = 22 },
    new User { Name = "Anton", Age = 27 }
};

// Ordinamento per età (usa CompareTo)
users.Sort();

// Stampa degli utenti ordinati
foreach (User user in users)
{
    Console.WriteLine($"{user.Name}, {user.Age}");
}

La lista sarà ordinata per età:

Maria, 22
Anton, 27
Sergey, 31

Visualizzazione: prima e dopo

Dopo l'ordinamento:

4. Dettagli importanti ed errori comuni

Protezione da null

Dentro CompareTo è fondamentale controllare che other non sia null. Se ti dimentichi, puoi beccarti un NullReferenceException — e sono fastidiosi come i bug il giorno prima del rilascio. Di solito, se l'oggetto confrontato è null, si considera che quello corrente sia "maggiore":

public int CompareTo(User other)
{
    if (other == null) return 1;
    // ...
}

Rispetta la transitività

Se A < B e B < C, allora A deve essere < C. Se non rispetti questa regola, l'ordinamento si comporterà in modo imprevedibile (cioè, divertente, ma sbagliato!).

Se l'ordinamento deve essere su più campi

Supponiamo che prima si ordini per età, ma se due utenti hanno la stessa età, li ordiniamo per nome in ordine alfabetico. Si fa così:

public int CompareTo(User other)
{
    if (other == null) return 1;

    int ageCompare = this.Age.CompareTo(other.Age);
    if (ageCompare != 0) return ageCompare;

    // Se l'età è uguale — confrontiamo per nome
    return this.Name.CompareTo(other.Name);
}

5. Ordinamento: ora anche con i tuoi oggetti

Tutto quello che può fare List<int> — ora lo può fare anche la tua classe

Ora puoi usare qualsiasi metodo che richiede il confronto: Sort, BinarySearch, anche l'inserimento in collezioni ordinate (tipo SortedSet<T>).

users.Sort();
// users ora è ordinato per età (e per nome se l'età è uguale)

Esempio nel contesto di un'app del corso

Supponiamo che prima hai già creato un'app per la gestione degli utenti. Ora possiamo aggiungere loro un ordine "naturale" direttamente nel codice esistente. Ecco come:

// La nostra classe User implementa già IComparable<User>

List<User> users = new List<User>
{
    new User { Name = "Ivan", Age = 45 },
    new User { Name = "Galina", Age = 27 },
    new User { Name = "Yuriy", Age = 27 }
};

// Ordiniamo per età, poi per nome
users.Sort();
foreach (var u in users)
{
    Console.WriteLine($"{u.Name} - {u.Age}");
}

Risultato:

Galina - 27
Yuriy - 27
Ivan - 45

Galina e Yuriy hanno la stessa età, quindi l'ordinamento va per nome se l'età è uguale.

6. Come funziona CompareTo: matematica dura

Ribadiamo lo standard dei valori di ritorno:

• Numero negativo (tipo -1): l'oggetto corrente viene prima di quello confrontato.
• Zero: sono considerati uguali per l'ordinamento.
• Numero positivo (tipo 1): l'oggetto corrente viene dopo quello confrontato.

I tipi built-in (tipo Age.CompareTo(other.Age)) già rispettano questo standard, restituendo sempre -1, 0 o 1.

Tabella dei valori di ritorno per il metodo CompareTo

20.CompareTo(21): -1

23.CompareTo(23): 0

42.CompareTo(15): 1

7. Ordinamento multiplo: combiniamo i campi

A volte serve un ordinamento più complesso: tipo per cognome, nome ed età. Usando la stessa tecnica, puoi confrontare in sequenza:

public class Student : IComparable<Student>
{
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public int Grade { get; set; }

    public int CompareTo(Student other)
    {
        if (other == null) return 1;
        int lastNameCompare = this.LastName.CompareTo(other.LastName);
        if (lastNameCompare != 0) return lastNameCompare;
        int firstNameCompare = this.FirstName.CompareTo(other.FirstName);
        if (firstNameCompare != 0) return firstNameCompare;
        return this.Grade.CompareTo(other.Grade);
    }
}

8. Quando NON dovresti implementare IComparable<T>

Situazione reale (da programmatore!): se un oggetto non ha un ordine "naturale" di ordinamento, meglio NON implementare IComparable<T>. Per esempio, se hai una classe Point e non sai — ordinare per X, per Y o per distanza dall'origine — allora è meglio che l'ordinamento venga passato dall'esterno tramite una funzione di confronto (IComparer<T>). Ne parleremo nella prossima lezione.