Comment : effectuer des jointures groupées (Guide de programmation C#)
La jointure groupée permet de produire des structures de données hiérarchiques. Elle associe chaque élément de la première collection à un jeu d'éléments corrélés de la deuxième collection.
Par exemple, une classe ou une table de base de données relationnelle nommée Student peut contenir deux champs : Id et Name. Une deuxième classe ou table de base de données relationnelle nommée Course peut contenir deux champs : StudentId et CourseTitle. Une jointure groupée de ces deux sources de données, basée sur les champs Student.Id et Course.StudentId correspondants, regroupe chaque Student avec une collection d'objets Course (qui peut être vide).
Notes
Chaque élément de la première collection apparaît dans le jeu de résultats d'une jointure groupée même si des éléments corrélés sont détectés dans la deuxième collection. Si aucun élément corrélé n'est détecté, la séquence d'éléments corrélés pour cet élément est vide. Le sélecteur de résultat a par conséquent accès à chaque élément de la première collection. Cela diffère du sélecteur de résultat dans une jointure non groupée, qui ne peut pas accéder aux éléments de la première collection qui n'ont pas de correspondance dans la deuxième collection.
Le premier exemple de cette rubrique vous montre comment effectuer une jointure groupée. Le deuxième exemple vous montre comment utiliser une jointure groupée pour créer des éléments XML.
Exemple
Exemple de Group Join
L'exemple suivant effectue une jointure groupée d'objets de type Person et Pet basés sur Person qui correspond à la propriété Pet.Owner. Contrairement à une jointure non groupée qui produit une paire d'éléments pour chaque correspondance, la jointure groupée produit un seul objet résultant pour chaque élément de la première collection, un objet Person dans cet exemple. Les éléments correspondants de la deuxième collection, qui sont des objets Pet dans cet exemple, sont groupés dans une collection. Enfin, la fonction de sélection de résultat crée un type anonyme pour chaque correspondance qui se compose de Person.FirstName et d'une collection d'objets Pet.
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:
Group Join pour créer un exemple XML
Les jointures groupées sont appropriées pour créer du XML à l'aide de LINQ to XML. L'exemple suivant est semblable à l'exemple précédent mais au lieu de créer des types anonymes, la fonction de sélection de résultat crée des éléments XML qui représentent les objets joints. Pour plus d'informations sur LINQ to XML, consultez 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>
Compilation du code
Créez un projet d'application console dans Visual Studio.
Ajoutez une référence à System.Core.dll et à System.Xml.Linq.dll si elles ne sont pas déjà référencées.
Incluez les espaces de noms System.Linq et System.Xml.Linq.
Copiez et collez le code à partir de l'exemple dans le fichier program.cs, sous la méthode Main. Ajoutez une ligne de code à la méthode Main pour appeler la méthode que vous avez collée.
Exécutez le programme.
Voir aussi
Tâches
Comment : effectuer des jointures internes (Guide de programmation C#)
Comment : effectuer des jointures externes gauches (Guide de programmation C#)
Référence
Types anonymes (Guide de programmation C#)