CodeGym /Corsi /C# SELF /Join di gruppo con group join

Join di gruppo con group join

C# SELF
Livello 33, Lezione 1
Disponibile

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.

2
Compito
C# SELF, livello 33, lezione 1
Bloccato
Un esempio semplice di utilizzo di `GroupJoin`
Un esempio semplice di utilizzo di `GroupJoin`
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION