1. Introduzione
Immagina il classico problema: hai due collezioni che sono logicamente collegate tra loro. Per esempio, una lista di categorie di prodotti e una lista dei prodotti stessi. Devi ottenere per ogni categoria tutti i prodotti di quella categoria. Oppure, hai una lista di reparti aziendali e una lista di dipendenti, e vuoi mostrare tutti i dipendenti per ogni reparto.
In SQL questa roba si chiama "join di gruppo" (GROUP JOIN o, più precisamente, LEFT OUTER JOIN con raggruppamento). In LINQ c'è un operatore apposta – GroupJoin. È una via di mezzo tra il join classico (Join), dove a ogni record di sinistra corrisponde esattamente uno di destra, e il raggruppamento per chiave. GroupJoin collega ogni elemento di una collezione con tutti gli elementi collegati dell'altra collezione sotto forma di collezione.
Analogia
Se il Join normale è come abbinare le coppie “padre e figlio” per cognome, il GroupJoin è come costruire un albero: a ogni padre alleghi la lista di tutti i suoi figli.
Schematizzato
Categorie Prodotti
+--------------+ +---------------------+
| Id | Nome | | Nome | CatId |
+----+---------+ +-----------+---------+
| 1 | Pane | ---> | Filone | 1 |
| 2 | Bevande | | Salame | 3 |
| 3 | Carne | | Pepsi | 2 |
| | | | Tè | 2 |
+----+---------+ +-----------+---------+
Dopo GroupJoin:
- Pane — [Filone]
- Bevande — [Pepsi, Tè]
- Carne — [Salame]
2. Firma del metodo e concetti base
Metodo di estensione
public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer, // Collezione "esterna" (tipo categorie)
IEnumerable<TInner> inner, // Collezione "interna" (tipo prodotti)
Func<TOuter, TKey> outerKeySelector, // Come ottenere la chiave dall'elemento esterno
Func<TInner, TKey> innerKeySelector, // Come ottenere la chiave dall'elemento interno
Func<TOuter, IEnumerable<TInner>, TResult> resultSelector // Factory per creare l'oggetto/record risultato
)
- outer: la collezione su cui si itera e a cui si collegano gli elementi (tipo categorie).
- inner: la collezione da cui si prendono gli elementi da collegare (tipo prodotti).
- outerKeySelector: lambda che restituisce la chiave per l'elemento "di sinistra".
- innerKeySelector: lambda che restituisce la chiave per l'elemento "di destra".
- resultSelector: funzione che decide come sarà il risultato per ogni coppia (sinistra+gruppo di destra).
3. Esempio pratico: categorie e prodotti
Supponiamo di avere questi modelli:
public class Category
{
public int Id { get; set; }
public string Name { get; set; }
}
public class Product
{
public string Name { get; set; }
public int CategoryId { get; set; }
}
Collezioni per l'esempio:
var categories = new List<Category>
{
new Category { Id = 1, Name = "Pane" },
new Category { Id = 2, Name = "Bevande" },
new Category { Id = 3, Name = "Carne" }
};
var products = new List<Product>
{
new Product { Name = "Filone", CategoryId = 1 },
new Product { Name = "Pepsi", CategoryId = 2 },
new Product { Name = "Tè", CategoryId = 2 },
new Product { Name = "Salame", CategoryId = 3 }
};
Uso di GroupJoin (Method Syntax)
var groupJoin = categories.GroupJoin(
products,
category => category.Id, // chiave categoria
product => product.CategoryId, // chiave prodotto
(category, prods) => new // costruiamo il risultato al volo
{
CategoryName = category.Name,
Products = prods.Select(p => p.Name).ToList() // lista dei nomi dei prodotti di questa categoria
}
);
Come ciclare il risultato:
foreach (var group in groupJoin)
{
Console.WriteLine($"Categoria: {group.CategoryName}");
foreach (var product in group.Products)
{
Console.WriteLine($" - {product}");
}
}
Output:
Categoria: Pane
- Filone
Categoria: Bevande
- Pepsi
- Tè
Categoria: Carne
- Salame
4. GroupJoin: Query Syntax (sintassi query)
LINQ supporta una sintassi simile a SQL. Per il group join si usa la parola chiave join ... into ..., e questa query funziona praticamente come l'esempio sopra.
var groupJoin2 = from c in categories
join p in products on c.Id equals p.CategoryId into prodGroup
select new
{
CategoryName = c.Name,
Products = prodGroup.Select(p => p.Name).ToList()
};
È molto simile a una query SQL con LEFT OUTER JOIN ... GROUP BY.
Schema visivo: come funziona GroupJoin
[Categoria] [Product] Raggruppamento (GroupJoin)
Pane --------> Filone => Pane: [Filone]
Bevande --------> Pepsi => Bevande: [Pepsi, Tè]
Bevande --------> Tè
Carne --------> Salame => Carne: [Salame]
Ogni categoria riceve la sua “tasca” (IEnumerable<Product>), dove finiscono tutti i prodotti di quella categoria.
5. Caratteristiche e insidie
GroupJoin vs. Join normale
La differenza tra il Join normale e il GroupJoin sta nel numero di risultati. Join restituisce una coppia per ogni match, mentre GroupJoin restituisce un elemento per ogni elemento della collezione esterna, dentro cui c'è una collezione di tutti gli elementi trovati.
Se nello schema c'è una categoria senza prodotti, con GroupJoin la vedrai comunque, solo che la sua collezione di prodotti sarà vuota. Questo comportamento è uguale al LEFT OUTER JOIN in SQL (join esterno sinistro).
Ecco un esempio con una categoria senza prodotti:
categories.Add(new Category { Id = 4, Name = "Formaggi" });
var groupJoin3 = categories.GroupJoin(
products,
c => c.Id,
p => p.CategoryId,
(c, prods) => new
{
CategoryName = c.Name,
Products = prods.Select(p => p.Name).ToList()
});
foreach (var group in groupJoin3)
{
Console.WriteLine($"Categoria: {group.CategoryName}");
if (group.Products.Count == 0)
Console.WriteLine(" (Nessun prodotto)");
else
foreach (var product in group.Products)
Console.WriteLine($" - {product}");
}
Categoria: Pane
- Filone
Categoria: Bevande
- Pepsi
- Tè
Categoria: Carne
- Salame
Categoria: Formaggi
(Nessun prodotto)
Questo scenario è molto richiesto nelle app business: bisogna mostrare tutte le categorie (o gruppi), anche se in qualcuna non ci sono elementi.
Implementazione tramite GroupBy? No!
Molti si confondono cercando di “emulare” GroupJoin usando un doppio GroupBy. Non farlo — GroupJoin è fatto apposta per questo e fa il “join sinistro” nativamente.
6. Uso con dati reali
In aggiunta alle lezioni precedenti, aggiungiamo alla nostra app didattica la possibilità di stampare un report: “Per ogni categoria — la lista dei suoi prodotti”. Questa cosa serve spesso in e-commerce, CRM, sistemi di contabilità o report.
Aggiungiamo il codice alla nostra demo-app:
// Supponiamo di avere le classi Category e Product e le collezioni già create
Console.WriteLine("REPORT PER CATEGORIE E PRODOTTI:");
var categoryReport = categories.GroupJoin(
products,
cat => cat.Id,
prod => prod.CategoryId,
(cat, prods) => new
{
cat.Name,
ProductNames = prods.Select(p => p.Name).ToList()
});
foreach (var row in categoryReport)
{
Console.WriteLine($"Categoria: {row.Name}");
if (row.ProductNames.Count == 0)
Console.WriteLine(" (Nessun prodotto)");
else
foreach (var prodName in row.ProductNames)
Console.WriteLine($" - {prodName}");
}
7. Raggruppamenti annidati e lavoro con aggregati
GroupJoin si può combinare con funzioni di aggregazione per fare report più complessi.
Esempio: Contare quanti prodotti ci sono in ogni categoria
var reportWithCount = categories.GroupJoin(
products,
category => category.Id,
product => product.CategoryId,
(category, prods) => new
{
Category = category.Name,
Count = prods.Count() // Funzione aggregata!
});
foreach (var rec in reportWithCount)
{
Console.WriteLine($"{rec.Category}: {rec.Count} prodotti");
}
Supponiamo che le collezioni categories e products abbiano questi dati:
var categories = new[]
{
new { Id = 1, Name = "Frutta" },
new { Id = 2, Name = "Verdura" },
new { Id = 3, Name = "Latticini" }
};
var products = new[]
{
new { Id = 1, Name = "Mela", CategoryId = 1 },
new { Id = 2, Name = "Banana", CategoryId = 1 },
new { Id = 3, Name = "Carota", CategoryId = 2 }
};
L'output in console sarà:
Categoria: Frutta — 2 prodotti
Categoria: Verdura — 1 prodotti
Categoria: Latticini — 0 prodotti
8. GroupJoin ed errori tipici dei principianti
Errore comune — aspettarsi che il risultato di GroupJoin sia una tabella piatta di coppie, come nel Join classico. Per "piatta" si intende una struttura dove ogni riga è una coppia: un elemento esterno e uno interno corrispondente (tipo tabella SQL dopo INNER JOIN).
Questo confonde soprattutto chi ha già lavorato un po' con i database: si aspettano che GroupJoin si comporti come un LEFT JOIN, ma che restituisca le coppie riga per riga, non i gruppi. Invece GroupJoin restituisce l'elemento della collezione esterna e la collezione degli elementi interni collegati — in pratica, una struttura annidata.
Ricordati di "espandere" le collezioni annidate quando serve — per esempio, usando SelectMany se vuoi ottenere una sequenza piatta di coppie.
Un altro errore comune — dimenticare che per gli elementi senza match il sottogruppo sarà semplicemente una lista vuota. Questo è il comportamento di default, non un bug — ma è importante ricordarselo per non stupirsi se nell'output "non succede niente".
Quando usare GroupJoin e quando no?
Usa GroupJoin:
- Quando hai due set di dati (tipo reparti e dipendenti, categorie e prodotti) e vuoi mostrarli in modo gerarchico: per ogni “genitore” tutti i suoi “figli”.
- Per creare report complessi dove è importante mostrare tutti gli elementi principali anche se non hanno “figli”.
- Quando ti serve l'equivalente SQL di LEFT OUTER JOIN con raggruppamento per chiave.
Non usare GroupJoin dove ti basta solo incrociare le collezioni o avere esattamente una coppia per match — lì va bene il Join classico.
GO TO FULL VERSION