Ausführen von Left Outer JoinsPerform left outer joins

Ein Left Outer Join ist eine Verknüpfung, die jedes Element der ersten Auflistung zurückgibt, unabhängig davon, ob es entsprechende Elemente in der zweiten Auflistung gibt.A left outer join is a join in which each element of the first collection is returned, regardless of whether it has any correlated elements in the second collection. Sie können LINQ verwenden, um eine linke äußere Verknüpfung auszuführen, indem die Methode DefaultIfEmpty bei den Ergebnissen einer Gruppenverknüpfung aufgerufen wird.You can use LINQ to perform a left outer join by calling the DefaultIfEmpty method on the results of a group join.

BeispielExample

Im folgenden Beispiel wird veranschaulicht, wie die Methode DefaultIfEmpty bei den Ergebnissen einer Gruppenverknüpfung verwendet wird, um eine linke äußere Verknüpfung auszuführen.The following example demonstrates how to use the DefaultIfEmpty method on the results of a group join to perform a left outer join.

Der erste Schritt zum Erstellen eines Left Outer Join von zwei Auflistungen besteht darin, eine innere Verknüpfung durch Gruppenverknüpfung auszuführen.The first step in producing a left outer join of two collections is to perform an inner join by using a group join. (Siehe Ausführen innerer Verknüpfungen für eine Erläuterung dieses Vorgangs.) In diesem Beispiel wird die Liste der Person-Objekte mit der Liste der Pet-Objekte anhand eines Person-Objekts, das mit Pet.Owner übereinstimmt, von innen verknüpft.(See Perform inner joins for an explanation of this process.) In this example, the list of Person objects is inner-joined to the list of Pet objects based on a Person object that matches Pet.Owner.

Der zweite Schritt besteht darin, jedes Element der ersten (linken) Liste in den Ergebnissatz einzuschließen, selbst wenn das Element in der rechten Auflistung keine Übereinstimmungen hat.The second step is to include each element of the first (left) collection in the result set even if that element has no matches in the right collection. Dies wird durch den Aufruf von DefaultIfEmpty für jede Sequenz von übereinstimmenden Elementen aus der Gruppenverknüpfung erreicht.This is accomplished by calling DefaultIfEmpty on each sequence of matching elements from the group join. In diesem Beispiel wird DefaultIfEmpty für jede Sequenz von übereinstimmenden Pet-Objekten aufgerufen.In this example, DefaultIfEmpty is called on each sequence of matching Pet objects. Diese Methode gibt eine Auflistung zurück, die einen einzelnen Standardwert enthält, wenn die Sequenz von übereinstimmenden Pet-Objekten für jedes Person-Objekt leer ist, womit die Methode sicherstellt, dass jedes Person-Objekt in der Ergebnisauflistung dargestellt wird.The method returns a collection that contains a single, default value if the sequence of matching Pet objects is empty for any Person object, thereby ensuring that each Person object is represented in the result collection.

Hinweis

Der Standardwert für einen Verweistyp ist null; deshalb wird im Beispiel nach einem NULL-Verweis gesucht, bevor auf jedes Element jeder Pet-Auflistung zugegriffen wird.The default value for a reference type is null; therefore, the example checks for a null reference before accessing each element of each Pet collection.

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void LeftOuterJoinExample()
{
    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 };

    var query = from person in people
                join pet in pets on person equals pet.Owner into gj
                from subpet in gj.DefaultIfEmpty()
                select new { person.FirstName, PetName = subpet?.Name ?? String.Empty };

    foreach (var v in query)
    {
        Console.WriteLine($"{v.FirstName+":",-15}{v.PetName}");
    }
}

// This code produces the following output:
//
// Magnus:        Daisy
// Terry:         Barley
// Terry:         Boots
// Terry:         Blue Moon
// Charlotte:     Whiskers
// Arlene:

Siehe auchSee also

Join
GroupJoin
Ausführen innerer VerknüpfungenPerform inner joins
Ausführen von GruppenverknüpfungenPerform grouped joins
Anonyme TypenAnonymous types