Ausführen von GruppenverknüpfungenPerform grouped joins

Die Gruppenverknüpfung ist nützlich für das Erstellen hierarchischer Datenstrukturen.The group join is useful for producing hierarchical data structures. Sie verbindet jedes Element aus der ersten Auflistung mit einem Satz von entsprechenden Elementen aus der zweiten Auflistung.It pairs each element from the first collection with a set of correlated elements from the second collection.

Eine Klasse oder relationale Datenbanktabelle namens Student kann z.B. zwei Felder enthalten: Id und Name.For example, a class or a relational database table named Student might contain two fields: Id and Name. Eine zweite Klasse oder relationale Datenbanktabelle namens Course kann zwei Felder enthalten: StudentId und CourseTitle.A second class or relational database table named Course might contain two fields: StudentId and CourseTitle. Eine Gruppenverknüpfung dieser beiden Datenquellen, die auf der übereinstimmenden Student.Id und Course.StudentId basiert, würde jeden Student mit einer Auflistung von Course-Objekten gruppieren (die vielleicht leer sind).A group join of these two data sources, based on matching Student.Id and Course.StudentId, would group each Student with a collection of Course objects (which might be empty).

Hinweis

Jedes Element der ersten Auflistung erscheint im Ergebnissatz einer Gruppenverknüpfung, unabhängig davon, ob entsprechende Elemente in der zweiten Auflistung gefunden werden.Each element of the first collection appears in the result set of a group join regardless of whether correlated elements are found in the second collection. Sollten keine entsprechenden Elemente gefunden werden, ist die Sequenz der entsprechenden Elemente für das Element leer.In the case where no correlated elements are found, the sequence of correlated elements for that element is empty. Die Ergebnisauswahl hat daher Zugriff auf jedes Element der ersten Auflistung.The result selector therefore has access to every element of the first collection. Dies unterscheidet sich von der Ergebnisauswahl in einer Verknüpfung, bei der keine Gruppen verknüpft werden. Diese kann nicht auf Elemente aus der ersten Auflistung zugreifen, die keine Übereinstimmung in der zweiten Auflistung haben.This differs from the result selector in a non-group join, which cannot access elements from the first collection that have no match in the second collection.

Im ersten Beispiel in diesem Thema wird das Ausführen einer Gruppenverknüpfung gezeigt.The first example in this topic shows you how to perform a group join. Im zweiten Beispiel wird gezeigt, wie eine Gruppenverknüpfung zum Erstellen von XML-Elementen verwendet wird.The second example shows you how to use a group join to create XML elements.

BeispielExample

Beispiel für eine GruppenverknüpfungGroup join example

Das folgende Beispiel führt eine Gruppenverknüpfung von Objekten des Typs Person und Pet aus, die auf der Person basiert und mit der Pet.Owner-Eigenschaft übereinstimmt.The following example performs a group join of objects of type Person and Pet based on the Person matching the Pet.Owner property. Bei einer Verknüpfung, bei der keine Gruppen verknüpft werden, wird für jede Übereinstimmung ein Elementpaar erzeugt. Im Gegensatz dazu erzeugt eine Gruppenverknüpfung nur ein resultierendes Objekt für jedes Element der ersten Auflistung, was in diesem Beispiel ein Person-Objekt ist.Unlike a non-group join, which would produce a pair of elements for each match, the group join produces only one resulting object for each element of the first collection, which in this example is a Person object. Die entsprechenden Elemente aus der zweiten Auflistung, die in diesem Beispiel Pet-Objekte sind, werden in einer Auflistung gruppiert.The corresponding elements from the second collection, which in this example are Pet objects, are grouped into a collection. Die Ergebnisauswahlfunktion erstellt schließlich einen anonymen Typ für jede Übereinstimmung, die aus Person.FirstName und einer Auflistung von Pet-Objekten besteht.Finally, the result selector function creates an anonymous type for each match that consists of Person.FirstName and a collection of Pet objects.

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:

BeispielExample

Gruppenverknüpfung zum Erstellen eines XML-BeispielsGroup join to create XML example

Gruppenverknüpfungen lassen sich ideal für das Erstellen von XML mithilfe von LINQ to XML nutzen.Group joins are ideal for creating XML by using LINQ to XML. Das folgende Beispiel ähnelt dem vorherigen, nur dass die Ergebnisauswahlfunktion anstatt eines anonymen Typs XML-Elemente erstellt, die die verknüpften Objekte darstellen.The following example is similar to the previous example except that instead of creating anonymous types, the result selector function creates XML elements that represent the joined objects.


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>

Siehe auchSee also

Join
GroupJoin
Ausführen innerer VerknüpfungenPerform inner joins
Ausführen linker äußerer VerknüpfungenPerform left outer joins
Anonyme TypenAnonymous types