Gruppierung von In-Memory-Listen in C# mit LINQ und Lambda-Ausdrücken

Bei der Arbeit mit Listen in C# können verschiedene Szenarien auftreten, in denen Sie Elemente basierend auf einer bestimmten Eigenschaft gruppieren müssen. Angenommen, Sie haben eine Sammlung von Foo-Objekten, und Sie möchten diese basierend auf den Werten ihrer Bar-Eigenschaften organisieren. Hier kommt die Leistungsfähigkeit von LINQ (Language Integrated Query) und Lambda-Ausdrücken ins Spiel. In diesem Blogbeitrag werden wir untersuchen, wie man In-Memory-Listen mit diesen C#-Funktionen effektiv gruppiert.

Das Problem verstehen

Stellen Sie sich vor, Sie haben eine Liste von Foo-Objekten, bei denen jedes Foo die Eigenschaften Bar und Lum hat. Einige Foo-Instanzen können denselben Wert für Bar teilen. Ihr Ziel ist es, diese Foo-Instanzen nach ihren Bar-Werten zu gruppieren und dann über die gruppierten Sammlungen zu iterieren, um auf ihre entsprechenden Lum-Werte zuzugreifen. Dies kann die Datenorganisation verbessern und es einfacher machen, bestimmte Datensätze zu manipulieren.

Beispielszenario

Betrachten wir ein spezifisches Beispiel mit der folgenden Liste von Foo-Instanzen:

var foos = new List<Foo> {
   new Foo{Bar = 1,Lum = 1},
   new Foo{Bar = 1,Lum = 2},
   new Foo{Bar = 2,Lum = 3},
};

Gewünschtes Ergebnis

Wir möchten diese Foo-Instanzen nach ihren Bar-Werten gruppieren, sodass letztendlich Folgendes entsteht:

• Für Bar = 1: Lum = 1, Lum = 2
• Für Bar = 2: Lum = 3

Lösung mit LINQ

Sie können die Foo-Objekte mithilfe der group by-Klausel von LINQ gruppieren. So wird es erreicht:

var groupedFoos = from foo in foos
                  group foo by foo.Bar into grouped
                  let lums = from g in grouped
                             select g.Lum
                  select new { Bar = grouped.Key, Lums = lums };

Schritte erklärt

• Gruppieren nach: Der Teil group foo by foo.Bar gruppiert die Foo-Instanzen basierend auf der Bar-Eigenschaft.
• In gruppiert: Dies erstellt einen neuen Geltungsbereich für jede Gruppe.
• Lum-Werte auswählen: Die Anweisung let lums ermöglicht es Ihnen, eine neue Sammlung zu erstellen, die aus Lum-Werten der gruppierten Objekte besteht.
• Endauswahl: Die abschließende Auswahl fügt alles zu einem neuen Objekt zusammen, das den Bar-Wert und die entsprechende Liste von Lum-Werten enthält.

Lösung mit Lambda-Ausdrücken

Alternativ können Sie dasselbe Ergebnis mit Lambda-Ausdrücken erzielen, die einen kompakteren Syntax bieten können. So geht’s:

var groupedFoos = foos.GroupBy(x => x.Bar)
                      .Select(y => new { Bar = y.Key, Lums = y.Select(z => z.Lum) });

So funktioniert es

• GroupBy: Diese Methode nimmt eine Lambda-Funktion, um die Eigenschaft anzugeben, nach der wir gruppieren möchten, nämlich x.Bar.
• Select: Nach der Gruppierung verwenden wir Select, um für jede Gruppe ein neues anonymer Objekt zu erstellen, das die Bar und die entsprechenden Lum-Werte enthält.

Iteration durch gruppierte Daten

Unabhängig davon, ob Sie LINQ oder Lambda-Ausdrücke verwenden, bleibt die Iteration durch die gruppierten Daten gleich. Sie können durch jede Gruppe iterieren und die Lum-Werte wie folgt ausgeben:

foreach (var group in groupedFoos)
{
    Console.WriteLine("Lums für Bar#" + group.Bar);
    foreach (var lum in group.Lums)
    {
        Console.WriteLine(lum);
    }
}

Die Ausgabe wird sein:

Lums für Bar#1
1
2
Lums für Bar#2
3

Fazit

Die Gruppierung von In-Memory-Listen mit LINQ oder Lambda-Ausdrücken in C# ist eine leistungsstarke Möglichkeit, Ihre Daten zu organisieren. Egal, ob Sie die Lesbarkeit der LINQ-Syntax oder die Kompaktheit von Lambda-Ausdrücken bevorzugen, beide Ansätze ermöglichen es Ihnen, die gewünschte Gruppierung Ihrer Daten effektiv zu erreichen.

Für diejenigen, die ihr Verständnis von LINQ vertiefen möchten, sollten Sie 101 LINQ-Beispiele erkunden, um umfassendere Beispiele zu erhalten.

Wenn Sie Fragen haben oder Ihre Erfahrungen mit der Gruppierung von Daten in C# teilen möchten, hinterlassen Sie gerne einen Kommentar unten!