Gewusst wie: Ausführen von Gruppenverknüpfungen (C#-Programmierhandbuch)
Aktualisiert: November 2007
Die Gruppenverknüpfung ist nützlich, um hierarchische Datenstrukturen zu erzeugen. Sie weist jedem Element aus der ersten Auflistung einen Satz korrelierter Elemente aus der zweiten Auflistung zu.
Eine Klasse oder eine relationale Datenbanktabelle mit dem Namen Student könnte beispielsweise zwei Felder enthalten: Id und Name. Eine zweite Klasse oder eine relationale Datenbanktabelle mit dem Namen Course könnte zwei Felder enthalten: StudentId und CourseTitle. Bei einer Gruppenverknüpfung dieser beiden Datenquellen anhand von übereinstimmender Student.Id und Course.StudentId würde jeder Student mit einer Auflistung von Course-Objekten (die leer sein können) gruppiert werden.
.gif "Hinweis") Hinweis: |
|---|
Jedes Element der ersten Auflistung wird im Ergebnissatz einer Gruppenverknüpfung angezeigt, unabhängig davon, ob korrelierte Elemente in der zweiten Auflistung gefunden werden. Wenn keine korrelierten Elemente gefunden werden, ist die Sequenz von korrelierten Elementen für dieses Element leer. Die Ergebnisauswahl hat daher Zugriff auf jedes Element der ersten Auflistung. Darin unterscheidet es sich von der Ergebnisauswahl in einer Nicht-Gruppenverknüpfung, die keinen Zugriff auf Elemente der ersten Auflistung hat, für die es keine Übereinstimmung in der zweiten Auflistung gibt. |
Das erste Beispiel in diesem Thema zeigt, wie eine Gruppenverknüpfung ausgeführt wird. Im zweiten Beispiel wird Ihnen gezeigt, wie eine Gruppenverknüpfung verwendet wird, um XML-Elemente zu erstellen.
Beispiel
Beispiel für Gruppenverknüpfung
Im folgenden Beispiel wird eine Gruppenverknüpfung von Objekten des Typs Person und Pet basierend auf der Person, die mit der Pet.Owner-Eigenschaft übereinstimmt, durchgeführt. Anders als bei einer Nicht-Gruppenverknüpfung, bei der ein Elementenpaar für jede Übereinstimmung erzeugt werden würde, erstellt die Gruppenverknüpfung nur ein Objekt für jedes Element der ersten Auflistung, in diesem Beispiel ein Person-Objekt. Die entsprechenden Elemente aus der zweiten Auflistung, bei denen es sich in diesem Beispiel um Pet-Objekte handelt, werden in einer Auflistung gruppiert. Die Ergebnisauswahlfunktion erstellt dann einen anonymen Typ für jede Übereinstimmung, der aus Person.FirstName und einer Auflistung von Pet-Objekten besteht.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
/// <summary>
/// This example performs a grouped join.
/// </summary>
public static void GroupJoinExample()
{
Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };
Pet barley = new Pet { Name = "Barley", Owner = terry };
Pet boots = new Pet { Name = "Boots", Owner = terry };
Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
Pet bluemoon = new Pet { Name = "Blue Moon", Owner = terry };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
List<Pet> pets = new List<Pet> { barley, boots, whiskers, bluemoon, daisy };
// Create a list where each element is an anonymous type
// that contains the person's first name and a collection of
// pets that are owned by them.
var query = from person in people
join pet in pets on person equals pet.Owner into gj
select new { OwnerName = person.FirstName, Pets = gj };
foreach (var v in query)
{
// Output the owner's name.
Console.WriteLine("{0}:", v.OwnerName);
// Output each of the owner's pet's names.
foreach (Pet pet in v.Pets)
Console.WriteLine(" {0}", pet.Name);
}
}
// This code produces the following output:
//
// Magnus:
// Daisy
// Terry:
// Barley
// Boots
// Blue Moon
// Charlotte:
// Whiskers
// Arlene:
Beispiel für eine Gruppenverknüpfung zum Erstellen von XML
Gruppenverknüpfungen sind ideal zum Erstellen von XML mit LINQ to XML. Das folgende Beispiel ähnelt dem vorherigen Beispiel mit der Ausnahme, dass die Ergebnisauswahlfunktion XML-Elemente anstelle eines anonymen Typs erstellt, die die verknüpften Objekte darstellen. Weitere Informationen über LINQ to XML finden Sie unter LINQ to XML.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
/// <summary>
/// This example creates XML output from a grouped join.
/// </summary>
public static void GroupJoinXMLExample()
{
Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };
Pet barley = new Pet { Name = "Barley", Owner = terry };
Pet boots = new Pet { Name = "Boots", Owner = terry };
Pet whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
Pet bluemoon = new Pet { Name = "Blue Moon", Owner = terry };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
List<Pet> pets = new List<Pet> { barley, boots, whiskers, bluemoon, daisy };
// Create XML to display the hierarchical organization of people and their pets.
XElement ownersAndPets = new XElement("PetOwners",
from person in people
join pet in pets on person equals pet.Owner into gj
select new XElement("Person",
new XAttribute("FirstName", person.FirstName),
new XAttribute("LastName", person.LastName),
from subpet in gj
select new XElement("Pet", subpet.Name)));
Console.WriteLine(ownersAndPets);
}
// This code produces the following output:
//
// <PetOwners>
// <Person FirstName="Magnus" LastName="Hedlund">
// <Pet>Daisy</Pet>
// </Person>
// <Person FirstName="Terry" LastName="Adams">
// <Pet>Barley</Pet>
// <Pet>Boots</Pet>
// <Pet>Blue Moon</Pet>
// </Person>
// <Person FirstName="Charlotte" LastName="Weiss">
// <Pet>Whiskers</Pet>
// </Person>
// <Person FirstName="Arlene" LastName="Huff" />
// </PetOwners>
Kompilieren des Codes
Erstellen Sie ein neues Konsolenanwendungsprojekt in Visual Studio.
Fügen Sie einen Verweis auf System.Core.dll und System.Xml.Linq.dll hinzu, wenn nicht bereits auf sie verwiesen wird.
Fügen Sie den System.Linq-Namespace und den System.Xml.Linq-Namespace hinzu.
Kopieren Sie den Code aus dem Beispiel, und fügen Sie ihn in die program.cs-Datei unter der Main-Methode ein. Fügen Sie der Main-Methode eine Codezeile hinzu, um die eingefügte Methode aufzurufen.
Führen Sie das Programm aus.
Siehe auch
Aufgaben
Gewusst wie: Ausführen innerer Verknüpfungen (C#-Programmierhandbuch)
Gewusst wie: Ausführen linker äußerer Verknüpfungrn (C#-Programmierhandbuch)
Konzepte
Referenz
Anonyme Typen (C#-Programmierhandbuch)