Fortgeschrittenes LINQ in C# (GroupBy, Join, Aggregate)

LINQ ist nicht auf einfaches Filtern und Sortieren beschränkt. Für komplexere Datenverarbeitung bietet es erweiterte Operatoren wie GroupBy, Join und Aggregate. In diesem Artikel sehen wir uns an, wie diese Operatoren mit Beispielen verwendet werden können.

GroupBy

GroupBy gruppiert die Elemente einer Kollektion nach einer bestimmten Eigenschaft. Auf den Gruppen können dann Abfragen durchgeführt werden, um statistische Informationen zu gewinnen.

using System;
using System.Linq;
using System.Collections.Generic;

var studenten = new List<(string Name, string Stadt)>
{
    ("Max", "Berlin"),
    ("Anna", "München"),
    ("Lukas", "Berlin"),
    ("Sarah", "München"),
    ("David", "Hamburg")
};

// Studenten nach Stadt gruppieren
var gruppen = studenten.GroupBy(s => s.Stadt);

foreach (var gruppe in gruppen)
{
    Console.WriteLine($"Stadt: {gruppe.Key} - Anzahl Studenten: {gruppe.Count()}");
    foreach (var student in gruppe)
        Console.WriteLine($"  {student.Name}");
}

// Ausgabe:
// Stadt: Berlin - Anzahl Studenten: 2
//   Max
//   Lukas
// Stadt: München - Anzahl Studenten: 2
//   Anna
//   Sarah
// Stadt: Hamburg - Anzahl Studenten: 1
//   David

Join

Join funktioniert ähnlich wie INNER JOIN in SQL und verbindet zwei Kollektionen über einen gemeinsamen Schlüssel.

var studenten = new List<(int Id, string Name)>
{
    (1, "Max"),
    (2, "Anna"),
    (3, "Lukas")
};

var noten = new List<(int StudentId, int Punkte)>
{
    (1, 90),
    (2, 75),
    (3, 82)
};

// Studenten mit Noten verknüpfen
var ergebnis = studenten.Join(
    noten,
    s => s.Id,            // äußerer Schlüssel
    n => n.StudentId,     // innerer Schlüssel
    (s, n) => new { s.Name, n.Punkte }
);

foreach (var item in ergebnis)
    Console.WriteLine($"{item.Name} → {item.Punkte}");

// Ausgabe:
// Max → 90
// Anna → 75
// Lukas → 82

Aggregate

Aggregate führt eine kumulative Operation auf einer Kollektion aus. Es funktioniert ähnlich wie eine Schleife und aktualisiert einen Akkumulatorwert, um ein Endergebnis zu erzeugen.

var zahlen = new List<int> { 2, 3, 4, 5 };

// Alle Zahlen multiplizieren
int produkt = zahlen.Aggregate((acc, n) => acc * n);
Console.WriteLine(produkt); // 120

// Eine Zeichenkette aus allen Zahlen erstellen
string text = zahlen.Aggregate("Zahlen:", (acc, n) => acc + " " + n);
Console.WriteLine(text);
// Ausgabe: Zahlen: 2 3 4 5

Beispielanwendung: Verkaufsbericht

Im folgenden Beispiel werden Verkaufsdaten mit GroupBy, Join und Aggregate verarbeitet.

public class Produkt
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

public class Verkauf
{
    public int ProduktId { get; set; }
    public int Menge { get; set; }
    public decimal Preis { get; set; }
}

class Program
{
    static void Main()
    {
        var produkte = new List<Produkt>
        {
            new Produkt { Id = 1, Name = "Laptop" },
            new Produkt { Id = 2, Name = "Telefon" },
            new Produkt { Id = 3, Name = "Tablet" }
        };

        var verkäufe = new List<Verkauf>
        {
            new Verkauf { ProduktId = 1, Menge = 2, Preis = 1000 },
            new Verkauf { ProduktId = 2, Menge = 5, Preis = 500 },
            new Verkauf { ProduktId = 1, Menge = 1, Preis = 950 },
            new Verkauf { ProduktId = 3, Menge = 3, Preis = 300 }
        };

        // Produkte mit Verkäufen verbinden
        var bericht = produkte.Join(
            verkäufe,
            p => p.Id,
            v => v.ProduktId,
            (p, v) => new { p.Name, v.Menge, v.Preis }
        );

        // Nach Produkt gruppieren
        var gruppenBericht = bericht.GroupBy(r => r.Name);

        foreach (var gruppe in gruppenBericht)
        {
            var umsatz = gruppe.Aggregate(0m, (acc, r) => acc + (r.Menge * r.Preis));
            Console.WriteLine($"{gruppe.Key} → Verkäufe: {gruppe.Count()}, Umsatz: {umsatz} EUR");
        }
    }
}

// Beispielausgabe:
// Laptop → Verkäufe: 2, Umsatz: 2950 EUR
// Telefon → Verkäufe: 1, Umsatz: 2500 EUR
// Tablet → Verkäufe: 1, Umsatz: 900 EUR

Kurz & Knapp

Ähnliche Artikel