CodeGym /Corsi /C# SELF /Operazioni Union, Intersect, Except in LINQ

Operazioni Union, Intersect, Except in LINQ

C# SELF
Livello 33, Lezione 3
Disponibile

1. Introduzione

Passiamo a un argomento davvero interessante e super usato nella pratica: le operazioni multiple di LINQ — Union, Intersect, Except. Ti permettono di lavorare con le collezioni come se stessi facendo vera algebra degli insiemi (o contando gli sticker in due pacchetti sulla scrivania di un programmatore — che, dai, è quasi la stessa cosa). Se non hai mai sentito parlare di algebra degli insiemi (o l'hai dimenticata), può sembrare una roba tosta. Ma in realtà è un concetto semplicissimo: immagina due sacchetti di frutta. L'algebra degli insiemi è il modo per capire quale frutta c'è in entrambi i sacchetti, quale solo in uno, e quale c'è se li unisci. È come giocare con gli sticker: puoi metterli tutti insieme, trovare quelli in comune o togliere alcuni dagli altri. Tutto qui.

Pratica: Questi metodi sono comodissimi quando devi unire i risultati di due query diverse, trovare gli elementi comuni o capire la differenza tra collezioni. Per esempio:

  • Creare una lista unica di tutti i prodotti che compaiono sia nella lista delle vendite che in quella degli acquisti.
  • Trovare i prodotti che ci sono sia lì che lì — le posizioni comuni.
  • O capire quali prodotti sono in magazzino ma non sono stati venduti — qualcuno è rimasto lì a prendere polvere!

Casi reali: L'algebra degli insiemi la trovi ovunque: filtrare utenti per abbonamenti, trovare chi era in diversi gruppi, cercare ordini unici o che si incrociano, confrontare i risultati di due query diverse al database e molto altro.

2. Operazione Union — unione di collezioni

Facile, quindi andiamo subito alla pratica. Supponiamo di avere due liste di prodotti:

List<string> warehouseProducts = new List<string> { "Latte", "Pane", "Formaggio", "Uova" };
List<string> recentlySold = new List<string> { "Pane", "Formaggio", "Salame", "Tè" };

Cosa fa Union?

Union restituisce gli elementi unici che ci sono almeno in una delle collezioni.
In pratica — unione.

var allProducts = warehouseProducts.Union(recentlySold);

foreach (var product in allProducts)
{
    Console.WriteLine(product);
}
// Stampa: Latte, Pane, Formaggio, Uova, Salame, Tè

Ecco come appare visivamente:

Magazzino Venduto Union (Unione)
Latte Pane Latte
Pane Formaggio Pane
Formaggio Salame Formaggio
Uova Tè Uova
Salame
Tè

In termini di algebra degli insiemi, Union è l'operazione "o": dammi tutto quello che c'è almeno da qualche parte. Immagina due scatole con tipi diversi di tè — se vuoi assaggiare tutti i gusti, non importa se un tè si ripete — lo bevi solo una volta.

Union rimuove automaticamente i duplicati (basandosi sull'implementazione di Equals e GetHashCode per il tipo degli elementi). Se fai l'unione per le tue classi (tipo Product), assicurati che questi metodi siano implementati bene, altrimenti Union si comporterà in modo strano: elementi uguali potrebbero essere considerati diversi!

Non dimenticare: l'ordine degli elementi nella collezione risultante mantiene l'ordine della prima collezione, e i nuovi vengono aggiunti in fondo (nell'ordine in cui appaiono per la prima volta nella seconda collezione).

Esempio con oggetti

Continuiamo la nostra app "Negozio". Abbiamo due liste di Product:

public class Product
{
    public string Name { get; set; }
    public string Category { get; set; }

    // Per far funzionare bene Union/Intersect/Except serve un buon Equals e GetHashCode!
    public override bool Equals(object? obj) =>
        obj is Product other && Name == other.Name && Category == other.Category;

    public override int GetHashCode() => HashCode.Combine(Name, Category);
}

List<Product> stock = new()
{
    new Product { Name = "Latte", Category = "Latticini" },
    new Product { Name = "Pane", Category = "Panetteria" },
};

List<Product> sold = new()
{
    new Product { Name = "Pane", Category = "Panetteria" },
    new Product { Name = "Salame", Category = "Salumi" },
};

var all = stock.Union(sold);

// Nota: gli elementi non si duplicano,
// anche se "sembrano" uguali, ma devono essere uguali secondo la logica.

foreach (var p in all)
    Console.WriteLine($"{p.Name} ({p.Category})");

Errore tipico: Se non sovrascrivi Equals/GetHashCode, Union considererà istanze diverse con gli stessi valori come elementi diversi!

3. Operazione Intersect — intersezione di collezioni

Intersect restituisce quegli elementi che sono presenti in tutte le collezioni di partenza. È una specie di "e" nell'algebra degli insiemi.

Esempio

Riprendiamo le liste dell'esempio precedente:

var commonProducts = warehouseProducts.Intersect(recentlySold);
foreach (var product in commonProducts)
{
    Console.WriteLine(product);
}
// Stampa: Pane, Formaggio

Visualizzazione:

Magazzino Venduto Intersect (Comune)
Pane Pane Pane
Formaggio Formaggio Formaggio

Dove può servire?

  • Vuoi sapere quali prodotti dal tuo magazzino sono stati venduti oggi.
  • Ai colloqui chiedono spesso: "Come trovi l'intersezione di due liste?" — LINQ lo fa in una riga!
  • Nelle app business l'intersezione serve spesso per filtrare su criteri combinati.

Particolarità ed errori tipici

Se un elemento c'è più volte nella collezione, nel risultato ci sarà solo una copia di quell'elemento.
Per oggetti complessi (tipo la classe Product) di nuovo conta avere Equals/GetHashCode fatti bene.

Esempio con oggetti

var commonObjects = stock.Intersect(sold);
foreach (var p in commonObjects)
    Console.WriteLine($"{p.Name} ({p.Category})");
// Stampa solo Pane (Panetteria)

4. Operazione Except — differenza tra collezioni

Except restituisce gli elementi che ci sono solo nella prima collezione, ma non nella seconda.

Esempio

var productsOnlyInStock = warehouseProducts.Except(recentlySold);
foreach (var product in productsOnlyInStock)
{
    Console.WriteLine(product);
}
// Stampa: Latte, Uova

Cioè, sono i prodotti che sono in magazzino, ma non sono stati venduti.

Visualizzazione:

Magazzino Venduto Except (solo magazzino)
Latte Latte
Uova Uova
Pane Pane (saltato)
Formaggio Formaggio (saltato)

Analogia

È come se togliessi dalla tua pila tutti quei documenti che hai già spedito — ti resta solo quello che hai ancora lì e da nessun'altra parte.

Esempio con oggetti

var unsold = stock.Except(sold);
foreach (var p in unsold)
    Console.WriteLine($"{p.Name} ({p.Category})");
// Stampa: Latte (Latticini)

! Cose non ovvie

Il metodo Except è sensibile all'ordine: A.Except(B) — non è la stessa cosa di B.Except(A)! La prima collezione è "da dove togli", la seconda è "cosa togli".

5. Unione e composizione di più operazioni con LINQ

A volte una sola operazione non basta. Supponiamo che tu voglia stampare i prodotti che ci sono solo in magazzino o solo tra i venduti — ma non in entrambe le collezioni (la cosiddetta "differenza simmetrica").

Differenza simmetrica ("XOR" per insiemi):

var onlyInOne = warehouseProducts.Except(recentlySold)
                   .Union(recentlySold.Except(warehouseProducts));
foreach (var product in onlyInOne)
{
    Console.WriteLine(product);
}
// Stampa: Latte, Uova, Salame, Tè

Per logiche più complesse è comodo combinare i metodi LINQ:

// Trova i prodotti che non sono né in magazzino né tra i venduti, ma solo nella lista "in arrivo"
List<string> expected = new() { "Caffè", "Tè", "Latte" };
var onlyExpected = expected.Except(warehouseProducts.Union(recentlySold));
foreach (var product in onlyExpected)
    Console.WriteLine(product);
// Stampa: Caffè

6. Lavorare con tipi custom e IEqualityComparer

A volte non ti serve confrontare gli oggetti su tutti i campi: magari ti interessa solo il nome del prodotto, e la categoria non conta. Per questo i metodi LINQ supportano un parametro extra — IEqualityComparer<T>, che decide come confrontare gli elementi.

Esempio di comparatore custom:

class ProductNameComparer : IEqualityComparer<Product>
{
    public bool Equals(Product? x, Product? y) => x?.Name == y?.Name;
    public int GetHashCode(Product obj) => obj.Name.GetHashCode();
}

var comp = new ProductNameComparer();
var uniqueByName = stock.Union(sold, comp);
foreach (var p in uniqueByName)
    Console.WriteLine(p.Name); // Latte, Pane, Salame

Questo è super comodo se non vuoi cambiare Equals/GetHashCode su tutto il modello, ma vuoi solo una volta confrontare gli oggetti secondo una regola specifica.

7. Schemi visivi e tabelle

Riassumiamo gli usi (per le liste A e B):

Operazione Risultato
A.Union(B)
Tutto quello che c'è in A o B (elementi unici).
A.Intersect(B)
Tutto quello che c'è in entrambi (A e B).
A.Except(B)
Tutto quello che c'è solo in A, ma non in B.

Schema (Venn Diagram, se solo potessimo disegnare):


      [A]        [B]
      oooooooooo
      oooooooo oooo
      ooooo oo   ooo
      ooo    ooo  oo
      oo      o  ooo
      ooo    ooo ooo
  • Union: tutto quello che sta dentro entrambi i cerchi.
  • Intersect: solo l'intersezione (il centro).
  • Except: solo quello che c'è nel cerchio A, senza toccare l'intersezione con B.

8. Errori tipici usando Union, Intersect e Except

Errore n°1: usare con oggetti senza Equals e GetHashCode.
Se la tua classe non ha questi metodi sovrascritti, i metodi Union, Intersect e Except funzioneranno male: oggetti uguali nei dati saranno considerati diversi. E ti ritrovi con risultati strani (e spesso inutili).

Errore n°2: provare a confrontare oggetti su solo alcuni campi senza IEqualityComparer.
Per esempio, se vuoi confrontare i prodotti solo per nome, e non per tutta la struttura, Intersect da solo non lo capisce. Senza un IEqualityComparer esplicito il risultato non sarà quello che ti aspetti.

Errore n°3: aspettarsi un certo ordine degli elementi.
Molti pensano che la collezione finale mantenga l'ordine dell'unione o dell'intersezione. Ma il comportamento dipende dal metodo: Union mantiene l'ordine della prima collezione, ma Intersect e Except possono restituire gli elementi in ordine imprevedibile. Meglio non contare mai sull'ordine.

Errore n°4: ignorare le performance con collezioni grandi.
Se i dati sono tanti, i metodi possono essere lenti. Pensa a fare aggregazioni, filtri o usare strutture hash (tipo HashSet) per velocizzare le operazioni.

2
Compito
C# SELF, livello 33, lezione 3
Bloccato
Utilizzo di Intersect per trovare elementi comuni
Utilizzo di Intersect per trovare elementi comuni
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION