CodeGym /Corsi /C# SELF /Unire collezioni con join ( Join)

Unire collezioni con join ( Join)

C# SELF
Livello 33, Lezione 0
Disponibile

1. Introduzione

A volte ci capita di lavorare con due collezioni diverse che sono collegate tra loro da qualche caratteristica comune. Per esempio, abbiamo una lista di ordini e una collezione separata di clienti. Come capire quale ordine appartiene a quale cliente? Per questo serve che entrambe le collezioni siano collegate tramite un identificatore comune — ad esempio tramite userId.

Nei database relazionali questo problema viene risolto dall'operazione JOIN, che unisce le righe di tabelle diverse tramite chiavi corrispondenti. In LINQ c'è un operatore analogo — si chiama anche lui Join.

Immagina due tabelle: nella prima — una lista di lettori della biblioteca con i loro identificatori, nella seconda — una lista di ordini di libri, dove ogni ordine ha l'id del lettore. Con join "incolliamo" queste tabelle tramite id, e otteniamo in uscita coppie “lettore + il suo ordine”.

Tra l'altro, se pensavi che join fosse solo per i "database", ti sei perso un sacco di cose! In programmazione capita spesso di dover unire collezioni, soprattutto quando lavori con sistemi esterni o file strutturati (JSON, XML e tutte quelle tabelle Excel della contabilità).

2. Firma del metodo Join e principio di funzionamento

Ecco come appare il metodo Join:


public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
    this IEnumerable<TOuter> outer,                 // prima collezione (esterna)
    IEnumerable<TInner> inner,                      // seconda collezione (interna)
    Func<TOuter, TKey> outerKeySelector,            // come ottenere la chiave dall'elemento esterno
    Func<TInner, TKey> innerKeySelector,            // come ottenere la chiave dall'interno
    Func<TOuter, TInner, TResult> resultSelector)   // funzione che genera il risultato (nuovo elemento)

A prima vista può sembrare pesante, ma ora mettiamo tutto in ordine.
Come funziona:
Per ogni elemento della prima collezione (outer) LINQ cerca gli elementi corrispondenti (per chiave) nella seconda (inner). Quando le chiavi coincidono, viene chiamato resultSelector e il risultato viene salvato nella collezione finale.

3. Esempio: Uniamo clienti e i loro ordini

Creiamo un paio di classi e collezioni. Questa idea è la naturale continuazione della nostra app didattica (facciamo finta sia un negozietto che sviluppiamo durante il corso).


public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
}

public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public string Product { get; set; } = "";
}

// Collezione di clienti
var customers = new List<Customer>
{
    new Customer { Id = 1, Name = "Vasya" },
    new Customer { Id = 2, Name = "Petya" },
    new Customer { Id = 3, Name = "Masha" },
};

// Collezione di ordini
var orders = new List<Order>
{
    new Order { Id = 101, CustomerId = 2, Product = "Libro" },
    new Order { Id = 102, CustomerId = 1, Product = "Penna" },
    new Order { Id = 103, CustomerId = 2, Product = "Quaderno" },
    new Order { Id = 104, CustomerId = 3, Product = "Gomma" },
};

Ora vogliamo ottenere tutti i clienti con i loro ordini. Ad esempio, stampare: "Petya ha ordinato Libro", "Petya ha ordinato Quaderno" ecc.

Applichiamo Join


// Uniamo clienti e ordini tramite customer.Id e order.CustomerId
var query = customers.Join(
    orders,
    customer => customer.Id,          // Come ottenere la chiave dal cliente
    order => order.CustomerId,        // Come ottenere la chiave dall'ordine
    (customer, order) => new          // Cosa fare con le coppie trovate (creiamo nuovo oggetto)
    {
        CustomerName = customer.Name,
        Product = order.Product
    }
);

// Stampiamo il risultato
foreach (var item in query)
{
    Console.WriteLine($"{item.CustomerName} ha ordinato {item.Product}");
}

Cosa verrà stampato:

Vasya ha ordinato Penna
Petya ha ordinato Libro
Petya ha ordinato Quaderno
Masha ha ordinato Gomma

Nota: se un cliente ha più ordini, apparirà nella lista più volte — una per ogni ordine. Ed è proprio così che deve essere!

4. Tabella: Confronto tra Join e GroupBy + SelectMany

Operazione Risultato Scenario d'uso
Join
Lista piatta di coppie Classico SQL JOIN. Ogni coppia (match) — una riga separata.
GroupBy + SelectMany
Gruppi con sottocollezioni Vuoi ottenere "cliente + tutti i suoi ordini" come struttura "uno a molti".

I principianti spesso usano Join dove serve una struttura “cliente → lista di ordini”. Ma Join lavora riga per riga e non raggruppa i dati. Per questo c'è GroupJoin — ne parliamo nella prossima lezione. Oppure puoi usare GroupBy.

5. Join in Query Syntax (stile SQL di LINQ)

LINQ supporta due sintassi: quella a catena di metodi (Method Syntax, tipo Join(...)) e il cosiddetto stile SQL (Query Syntax), che visivamente ricorda le query SQL classiche.

Per alcuni sviluppatori — soprattutto chi ha già lavorato con database — questa sintassi può essere più chiara:


var query2 =
    from customer in customers
    join order in orders
        on customer.Id equals order.CustomerId
    select new
    {
        CustomerName = customer.Name,
        Product = order.Product
    };

foreach (var item in query2)
{
    Console.WriteLine($"{item.CustomerName} ha ordinato {item.Product}");
}

Nota bene:
In Query Syntax si usa la parola chiave equals — l'operatore == qui non funziona!
Questo è un tranello classico ai colloqui, soprattutto per chi è alle prime armi 😉

6. Dettagli importanti e insidie

A volte succede che non tutti gli elementi delle collezioni finiscono nel risultato finale. Questo perché il metodo Join implementa il cosiddetto «inner join», cioè unisce solo gli elementi con chiavi corrispondenti. Se un cliente non ha ordini, semplicemente non ci sarà nella lista finale. Allo stesso modo, se c'è un ordine con CustomerId che non esiste tra i clienti, quell'ordine non finirà nel risultato.

Ma cosa fare se vuoi ottenere tutti i clienti, anche quelli senza ordini? In questi casi serve il "left join", che in LINQ si fa combinando GroupJoin e SelectMany. Ne parleremo nella prossima lezione. Nel classico Join invece, è obbligatorio che entrambi i lati siano presenti — altrimenti non c'è match e l'elemento viene escluso dal risultato.

7. Lavorare con più chiavi (composite key)

A volte bisogna unire collezioni non su un solo campo, ma su più campi. Per esempio: unire prodotti e le loro vendite tramite "Codice-prodotto + Anno-vendita".

In LINQ si risolve creando oggetti anonimi come chiavi:


var sales = ...; // vendite
var products = ...; // prodotti

var query = products.Join(
    sales,
    prod => new { prod.Code, prod.Year },
    sale => new { sale.ProductCode, sale.Year },
    (prod, sale) => new { prod.Name, sale.Amount }
);

È importante che tipi e nomi delle proprietà in questi oggetti anonimi coincidano. Se sono diversi, non verrà trovato nessun match — anche se i valori sono uguali nel senso.

8. Come appare la collezione unita — schema

Ecco uno schema che illustra come funziona il join (molto semplificato):


flowchart LR
    subgraph Customers
        A1["Vasya (Id=1)"]
        A2["Petya (Id=2)"]
        A3["Masha (Id=3)"]
    end
    subgraph Orders
        B1["Penna (CustomerId=1)"]
        B2["Libro (CustomerId=2)"]
        B3["Quaderno (CustomerId=2)"]
        B4["Gomma (CustomerId=3)"]
    end

    A1-->|Id=1|B1
    A2-->|Id=2|B2
    A2-->|Id=2|B3
    A3-->|Id=3|B4
Schema di unione tra clienti e ordini tramite chiave

Dallo schema si vede che ogni cliente viene collegato a tutti i suoi ordini — se le chiavi coincidono.

9. In breve su errori e particolarità

Uno degli errori più frequenti è invertire l'ordine dei parametri, soprattutto se i tipi delle chiavi nelle due collezioni sono uguali. In questo caso il compilatore o LINQ non daranno errore, ma il risultato potrebbe essere vuoto o strano.

Un'altra trappola comune è cercare di fare un "left join" con Join, per avere tutti i clienti anche senza ordini. Ma il classico Join funziona solo con coppie corrispondenti e non include elementi senza match.

2
Compito
C# SELF, livello 33, lezione 0
Bloccato
Unione semplice delle liste di clienti e ordini
Unione semplice delle liste di clienti e ordini
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION