How to: Realizar associações agrupadas (guia de programação C#)
A associação de grupo é útil para produzir estruturas de dados hierárquicos. Pares de cada elemento da coleção primeiro com um conjunto de elementos correlacionados da segunda coleção.
Por exemplo, uma classe ou uma tabela de banco de dados relacional, chamado aluno pode conter dois campos: ID e nome. Uma tabela de banco de dados relacionais ou segunda classe denominada o curso pode conter dois campos: StudentId e CourseTitle. Uma associação de grupo desses dados de duas fontes, com base na correspondência de Student.Id e Course.StudentId, agruparia cada aluno com uma coleção de objetos do curso (que pode ser vazia).
.gif "Observação") Observação |
|---|
Cada elemento da coleção primeiro aparece no conjunto de resultados de uma associação de grupo, independentemente de se correlacionados elementos são encontrados na segunda coleção. No caso onde não há elementos correlacionados são encontrados, a seqüência dos elementos correlacionados para esse elemento está vazia. O seletor de resultado, portanto, tem acesso a todos os elementos da coleção primeiro. Isso difere do seletor de resultado em uma associação de grupo, que não consegue acessar os elementos da primeira coleção que não têm correspondências na segunda coleção. |
O primeiro exemplo neste tópico mostra como executar uma associação de grupo. O segundo exemplo mostra como usar uma associação de grupo para criar elementos XML.
Exemplo
Exemplo de associação de grupo
O exemplo a seguir executa uma associação de grupo de objetos do tipo Person e Pet baseia o Person correspondentes a Pet.Owner propriedade. Ao contrário de uma associação de grupo, o que produziria um par de elementos para cada correspondência, a associação de grupo produz apenas um objeto resultante para cada elemento da primeira coleção, que, neste exemplo, é um Person objeto. Os elementos correspondentes da segunda coleção, que, neste exemplo, são Pet objetos, são agrupados em uma coleção. Finalmente, a função de seletor resultado cria um tipo anônimo para cada correspondência que consiste em Person.FirstName e uma coleção de Pet objetos.
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:
Associação de grupo para criar o exemplo de XML
Associações de grupo são ideais para criação de XML usando LINQ to XML. O exemplo a seguir é semelhante ao exemplo anterior, exceto que em vez de criar os tipos anônimos, a função de seletor de resultado cria elementos XML que representam os objetos associados. Para obter mais informações sobre o LINQ to XML, consulte 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>
Compilando o código
Criar uma nova Aplicativo de Console projeto em Visual Studio.
Adicione uma referência a System.Core.dll e System.Xml.Linq.dll se eles já não estão referenciados.
Incluir o System.Linq e System.Xml.Linq namespaces.
Copie e cole o código do exemplo no arquivo Program. cs, abaixo de Main método. Adicionar uma linha de código para o Main método para chamar o método que você colou pol.
Execute o programa.
Consulte também
Tarefas
How to: Realizar associações de interno (guia de programação C#)
How to: Executar esquerda junções externas (guia de programação de C#)
Referência
Tipos anônimos (guia de programação de C#)