Gewusst wie: Ausführen innerer Verknüpfungen (C#-Programmierhandbuch)
Bei relationalen Datenbanken erstellt ein innerer Join einen Ergebnissatz, in dem jedes Element der ersten Auflistung einmal für jedes übereinstimmende Element in der zweiten Auflistung angezeigt wird. Wenn ein Element in der ersten Auflistung keine übereinstimmenden Elemente hat, wird es nicht im Ergebnissatz angezeigt. Die Join-Methode, die von der join-Klausel in C# aufgerufen wird, implementiert einen inneren Join.
Dieses Thema zeigt vier Variationen, wie Sie einen inneren Join ausführen können:
Ein einfacher innerer Join, der Elemente aus zwei Datenquellen anhand eines einfachen Schlüssels verknüpft.
Ein innerer Join, der Elemente aus zwei Datenquellen anhand eines zusammengesetzten Schlüssels verknüpft. Ein zusammengesetzter Schlüssel besteht aus mehr als einem Wert und ermöglicht es Ihnen, Elemente anhand mehr als einer Eigenschaft zu verknüpfen.
Ein Mehrfachjoin, in dem aufeinander folgende Joinoperationen aneinander angefügt werden.
Ein innerer Join, der durch einen Group Join implementiert wird.
Beispiel
Beispiel für Join mit einfachem Schlüssel
Im folgenden Beispiel werden zwei Auflistungen erstellt, die Objekte von zwei benutzerdefinierten Typen, Person und Pet, enthalten. Die Abfrage verwendet die join-Klausel in C#, um die Person-Objekte mit Pet-Objekten abzugleichen, deren Owner diese Person ist. Die select-Klausel in C# definiert die Darstellung der resultierenden Objekte. In diesem Beispiel handelt es sich bei den erstellten Objekten um anonyme Typen, die aus dem Vornamen des Besitzers und dem Namen des Tiers bestehen.
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>
/// Simple inner join.
/// </summary>
public static void InnerJoinExample()
{
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" };
Person rui = new Person { FirstName = "Rui", LastName = "Raposo" };
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 = rui };
Pet daisy = new Pet { Name = "Daisy", Owner = magnus };
// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene, rui };
List<Pet> pets = new List<Pet> { barley, boots, whiskers, bluemoon, daisy };
// Create a collection of person-pet pairs. Each element in the collection
// is an anonymous type containing both the person's name and their pet's name.
var query = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.FirstName, PetName = pet.Name };
foreach (var ownerAndPet in query)
{
Console.WriteLine("\"{0}\" is owned by {1}", ownerAndPet.PetName, ownerAndPet.OwnerName);
}
}
// This code produces the following output:
//
// "Daisy" is owned by Magnus
// "Barley" is owned by Terry
// "Boots" is owned by Terry
// "Whiskers" is owned by Charlotte
// "Blue Moon" is owned by Rui
Beachten Sie, dass das Person-Objekt, dessen LastName "Huff" ist, nicht im Ergebnissatz angezeigt wird, da es kein Pet-Objekt gibt, bei dem Pet.Owner dieser Person entspricht.
Beispiel für Join mit zusammengesetztem Schlüssel
Anstatt Elemente anhand nur einer Eigenschaft zu verknüpfen, können Sie mit einem zusammengesetzten Schlüssel Elemente anhand mehrerer Eigenschaften vergleichen. Geben Sie dazu die Schlüsselauswahlfunktion für jede Auflistung an, um einen anonymen Typ zurückzugeben, der aus den Eigenschaften besteht, die Sie vergleichen möchten. Wenn Sie die Eigenschaften beschriften, müssen sie die gleiche Bezeichnung im anonymen Typ jedes Schlüssels haben. Die Eigenschaften müssen auch in der gleichen Reihenfolge angezeigt werden.
Im folgenden Beispiel wird mit einer Liste von Employee-Objekten und einer Liste von Student-Objekten festgelegt, welche Angestellten ebenfalls Studenten sind. Beide Typen verfügen über eine FirstName-Eigenschaft und eine LastName-Eigenschaft des Typs String. Die Funktionen, mit denen die Joinschlüssel aus den Elementen jeder Liste erstellt werden, geben einen anonymen Typ zurück, der aus der FirstName-Eigenschaft und der LastName-Eigenschaft jedes Elements besteht. Die Joinoperation vergleicht diese zusammengesetzten Schlüssel auf Gleichheit und gibt Objektpaare aus jeder Liste zurück, wenn der Vor- und Nachname übereinstimmen.
class Employee
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int EmployeeID { get; set; }
}
class Student
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int StudentID { get; set; }
}
/// <summary>
/// Performs a join operation using a composite key.
/// </summary>
public static void CompositeKeyJoinExample()
{
// Create a list of employees.
List<Employee> employees = new List<Employee> {
new Employee { FirstName = "Terry", LastName = "Adams", EmployeeID = 522459 },
new Employee { FirstName = "Charlotte", LastName = "Weiss", EmployeeID = 204467 },
new Employee { FirstName = "Magnus", LastName = "Hedland", EmployeeID = 866200 },
new Employee { FirstName = "Vernette", LastName = "Price", EmployeeID = 437139 } };
// Create a list of students.
List<Student> students = new List<Student> {
new Student { FirstName = "Vernette", LastName = "Price", StudentID = 9562 },
new Student { FirstName = "Terry", LastName = "Earls", StudentID = 9870 },
new Student { FirstName = "Terry", LastName = "Adams", StudentID = 9913 } };
// Join the two data sources based on a composite key consisting of first and last name,
// to determine which employees are also students.
IEnumerable<string> query = from employee in employees
join student in students
on new { employee.FirstName, employee.LastName }
equals new { student.FirstName, student.LastName }
select employee.FirstName + " " + employee.LastName;
Console.WriteLine("The following people are both employees and students:");
foreach (string name in query)
Console.WriteLine(name);
}
// This code produces the following output:
//
// The following people are both employees and students:
// Terry Adams
// Vernette Price
Beispiel für Mehrfachjoin
Jede beliebige Anzahl von Joinoperationen kann aneinander angefügt werden, um einen Mehrfachjoin durchzuführen. Jede join-Klausel in C# verknüpft eine angegebene Datenquelle mit den Ergebnissen des vorherigen Joins.
Im folgenden Beispiel werden drei Auflistungen erstellt: eine Liste mit Person-Objekten, eine Liste mit Cat-Objekten und eine mit Dog-Objekten.
Die erste join-Klausel in C# gleicht Personen und Katzen anhand eines Person-Objekts, das Cat.Owner entspricht, miteinander ab. Es wird eine Sequenz anonymer Typen zurückgegeben, die das Person-Objekt und Cat.Name enthält.
Die zweite join-Klausel in C# verknüpft die anonymen Typen, die vom ersten Join mit Dog-Objekten in der angegebenen Liste mit Hunden zurückgegeben wurden, anhand eines zusammengesetzten Schlüssels, der aus der Owner-Eigenschaft des Typs Person und dem ersten Buchstaben des Tiernamens besteht. Es wird eine Sequenz anonymer Typen zurückgegeben, die die Cat.Name-Eigenschaft und die Dog.Name-Eigenschaft jedes übereinstimmenden Paars enthält. Da es sich hierbei um einen inneren Join handelt, werden nur die Objekte aus der ersten Datenquelle, für die es eine Übereinstimmung in der zweiten Datenquelle gibt, zurückgegeben.
class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}
class Cat : Pet
{ }
class Dog : Pet
{ }
public static void MultipleJoinExample()
{
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" };
Person rui = new Person { FirstName = "Rui", LastName = "Raposo" };
Person phyllis = new Person { FirstName = "Phyllis", LastName = "Harris" };
Cat barley = new Cat { Name = "Barley", Owner = terry };
Cat boots = new Cat { Name = "Boots", Owner = terry };
Cat whiskers = new Cat { Name = "Whiskers", Owner = charlotte };
Cat bluemoon = new Cat { Name = "Blue Moon", Owner = rui };
Cat daisy = new Cat { Name = "Daisy", Owner = magnus };
Dog fourwheeldrive = new Dog { Name = "Four Wheel Drive", Owner = phyllis };
Dog duke = new Dog { Name = "Duke", Owner = magnus };
Dog denim = new Dog { Name = "Denim", Owner = terry };
Dog wiley = new Dog { Name = "Wiley", Owner = charlotte };
Dog snoopy = new Dog { Name = "Snoopy", Owner = rui };
Dog snickers = new Dog { Name = "Snickers", Owner = arlene };
// Create three lists.
List<Person> people =
new List<Person> { magnus, terry, charlotte, arlene, rui, phyllis };
List<Cat> cats =
new List<Cat> { barley, boots, whiskers, bluemoon, daisy };
List<Dog> dogs =
new List<Dog> { fourwheeldrive, duke, denim, wiley, snoopy, snickers };
// The first join matches Person and Cat.Owner from the list of people and
// cats, based on a common Person. The second join matches dogs whose names start
// with the same letter as the cats that have the same owner.
var query = from person in people
join cat in cats on person equals cat.Owner
join dog in dogs on
new { Owner = person, Letter = cat.Name.Substring(0, 1) }
equals new { dog.Owner, Letter = dog.Name.Substring(0, 1) }
select new { CatName = cat.Name, DogName = dog.Name };
foreach (var obj in query)
{
Console.WriteLine(
"The cat \"{0}\" shares a house, and the first letter of their name, with \"{1}\".",
obj.CatName, obj.DogName);
}
}
// This code produces the following output:
//
// The cat "Daisy" shares a house, and the first letter of their name, with "Duke".
// The cat "Whiskers" shares a house, and the first letter of their name, with "Wiley".
Innerer Join mithilfe des Beispiels für Group Joins
Im folgenden Beispiel wird gezeigt, wie Sie einen inneren Join implementieren können, indem Sie einen Group Join verwenden.
In query1 ist die Liste der Person-Objekte über einen Group Join mit der Liste der Pet-Objekte verknüpft, wobei die Person mit der Pet.Owner-Eigenschaft übereinstimmt. Der Group Join erstellt eine Auflistung von Zwischengruppen, wobei jede Gruppe aus einem Person-Objekt und einer Sequenz übereinstimmender Pet-Objekte besteht.
Durch das Hinzufügen einer zweiten from-Klausel zur Abfrage wird diese Sequenz mit Sequenzen zu einer längeren Sequenz zusammengefasst (vereinfacht). Der Typ der Elemente der endgültigen Sequenz wird mit der select-Klausel angegeben. In diesem Beispiel ist der Typ ein anonymer Typ, der aus der Person.FirstName-Eigenschaft und der Pet.Name-Eigenschaft für jedes übereinstimmende Paar besteht.
Das Ergebnis von query1 entspricht dem Resultset, das zum Ausführen eines inneren Joins mit der join-Klausel ohne die into-Klausel zurückgegeben wird. Die query2-Variable veranschaulicht diese entsprechende Abfrage.
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>
/// Performs an inner join by using GroupJoin().
/// </summary>
public static void InnerGroupJoinExample()
{
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 query1 = from person in people
join pet in pets on person equals pet.Owner into gj
from subpet in gj
select new { OwnerName = person.FirstName, PetName = subpet.Name };
Console.WriteLine("Inner join using GroupJoin():");
foreach (var v in query1)
{
Console.WriteLine("{0} - {1}", v.OwnerName, v.PetName);
}
var query2 = from person in people
join pet in pets on person equals pet.Owner
select new { OwnerName = person.FirstName, PetName = pet.Name };
Console.WriteLine("\nThe equivalent operation using Join():");
foreach (var v in query2)
Console.WriteLine("{0} - {1}", v.OwnerName, v.PetName);
}
// This code produces the following output:
//
// Inner join using GroupJoin():
// Magnus - Daisy
// Terry - Barley
// Terry - Boots
// Terry - Blue Moon
// Charlotte - Whiskers
//
// The equivalent operation using Join():
// Magnus - Daisy
// Terry - Barley
// Terry - Boots
// Terry - Blue Moon
// Charlotte - Whiskers
Kompilieren des Codes
Erstellen Sie ein neues Konsolenanwendungsprojekt in Visual Studio.
Fügen Sie einen Verweis auf System.Core.dll hinzu, wenn er noch nicht vorhanden ist.
Schließen Sie den System.Linq-Namespace ein.
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 von Gruppenverknüpfungen (C#-Programmierhandbuch)
Gewusst wie: Ausführen linker äußerer Verknüpfungen (C#-Programmierhandbuch)
Vorgehensweise: Verknüpfen zweier Auflistungen (C#) (LINQ to XML)
Referenz
Anonyme Typen (C#-Programmierhandbuch)