GroupBy, Join, Aggregate und Projektionen (anonyme Typen)
Gruppieren Sie Elemente, verknüpfen Sie Sequenzen, reduzieren Sie sie mit Aggregate und erzeugen Sie mit anonymen Typen übersichtliche Projektionen.
GroupBy, Join, Aggregate und Projektionen (anonyme Typen) ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Überblick über fortgeschrittene Operatoren
Heute:
- GroupBy: Buckets nach einem Schlüssel erstellen
- Join: zwei Sequenzen anhand eines Schlüssels kombinieren
- Aggregate: auf einen einzelnen Wert reduzieren
- Anonyme Typen: übersichtliche Projektionen
Gruppieren nach Schlüssel
GroupBy erstellt Gruppen mit einem Key und einer inneren Sequenz von Elementen, die diesen Schlüssel gemeinsam haben.
using System;
using System.Linq;
public class Program
{
public static void Main(string[] args)
{
string[] words = new string[] { "ant", "cat", "tiger", "lion", "dog", "eagle" };
var groups = words.GroupBy(w => w.Length);
foreach (var g in groups)
{
Console.WriteLine("Len " + g.Key + ":");
foreach (string w in g) Console.WriteLine(" - " + w);
}
}
}
Innerer Join nach Schlüssel
Join ordnet Elemente aus zwei Sequenzen anhand eines Schlüssels einander zu und projiziert das kombinierte Ergebnis.
using System;
using System.Linq;
public sealed class Customer { public int Id; public string Name; public Customer(int id, string name){ Id=id; Name=name; } }
public sealed class Order { public int CustomerId; public string Item; public Order(int cid, string item){ CustomerId=cid; Item=item; } }
public class Program
{
public static void Main(string[] args)
{
var customers = new Customer[] { new Customer(1,"Ada"), new Customer(2,"Bob") };
var orders = new Order[] { new Order(1,"Book"), new Order(1,"Pen"), new Order(2,"Map") };
var joined = customers.Join(
orders,
c => c.Id,
o => o.CustomerId,
(c, o) => c.Name + " -> " + o.Item);
foreach (string s in joined) Console.WriteLine(s);
}
}
Grundlagen von Aggregate
Aggregate wendet einen Akkumulator an, um eine Sequenz auf ein Ergebnis zu reduzieren. Wählen Sie einen geeigneten Startwert.
using System;
using System.Linq;
public class Program
{
public static void Main(string[] args)
{
int[] xs = new int[] { 1, 2, 3, 4 };
// Product with seed 1
int product = xs.Aggregate(1, (acc, n) => acc * n);
Console.WriteLine("Product = " + product); // 24
// Join words with a separator using seed
string[] words = new string[] { "a", "b", "c" };
string csv = words.Aggregate("", (acc, w) => acc == "" ? w : acc + "," + w);
Console.WriteLine(csv); // a,b,c
}
}
Projektion mit anonymen Typen
Verwenden Sie anonyme Typen für übersichtliche Projektionen: new { Name = c.Name, ... } oder in Kurzform new { c.Name }.
using System;
using System.Linq;
public sealed class City { public string Name; public int Pop; public City(string n,int p){ Name=n; Pop=p; } }
public class Program
{
public static void Main(string[] args)
{
var cities = new City[]
{
new City("Oslo", 634000),
new City("Rome", 2873000),
new City("Riga", 605000)
};
var small = cities
.Where(c => c.Pop < 1000000)
.Select(c => new { c.Name, Millions = (c.Pop / 1000000.0) });
foreach (var x in small)
{
Console.WriteLine(x.Name + " ~ " + x.Millions + "M");
}
}
}
Praktische Tipps
Tipps:
- Durchlaufen Sie nach GroupBy zuerst die Gruppen und dann die Elemente.
- Verwenden Sie Join, wenn Sie zwei Quellen mit übereinstimmenden Schlüsseln haben.
- Wählen Sie für Aggregate einen sinnvollen Startwert.
- Anonyme Typen sind lokal; geben Sie aus öffentlichen APIs konkrete DTOs zurück.
Zweck von GroupBy
Zusammenfassung
Zusammenfassung: Verwenden Sie GroupBy für Buckets, Join zum Kombinieren von Quellen, Aggregate zum Reduzieren und anonyme Typen für übersichtliche Projektionen.
Häufig gestellte Fragen
Ist die Lektion „GroupBy, Join, Aggregate und Projektionen (anonyme Typen)“ kostenlos?
Ja — der vollständige Text von „GroupBy, Join, Aggregate und Projektionen (anonyme Typen)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „GroupBy, Join, Aggregate und Projektionen (anonyme Typen)“?
Gruppieren Sie Elemente, verknüpfen Sie Sequenzen, reduzieren Sie sie mit Aggregate und erzeugen Sie mit anonymen Typen übersichtliche Projektionen. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C# Academy zu starten?
Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.
Wie lange dauert die Lektion „GroupBy, Join, Aggregate und Projektionen (anonyme Typen)“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?
Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- GroupBy, Join, Aggregate und Projektionen (anonyme Typen)
- Materialisierung (ToList, ToDictionary) und Performance-Hinweise
- Tipps zur Komponierbarkeit