Compartilhar via

Como: Executar associações agrupadas (guia de programação translation from VPE for Csharp)

  • Artigo

A unir de agrupar é útil para produzir estruturas de dados hierárquicos.Pares de cada elemento da coleção primeiro com um conjunto de correlacionados elementos da coleção segundo.

Por exemplo, uma classe ou uma tabela de banco de dados relacional denominada aluno pode conter dois campos: ID e nome.Uma tabela de banco de dados relacionais ou segunda classe denominada curso pode conter dois campos: StudentId e CourseTitle.Uma unir de grupo desses duas dados fontes, com base na correspondência Student.Id e Course.StudentId, seriam agrupar cada aluno com uma coleção de objetos de curso (que pode estar em branco).

Observação:

Cada elemento da coleção primeiro aparece no conjunto de resultados de uma unir de agrupar independentemente de elementos correlacionados são encontrados na coleção de segunda.No caso onde não correlacionados elementos forem encontrados, t sequência elementos correlacionados para que element é vazio .No seletor de resultado, portanto, tenha acesso para cada elemento da coleção primeiro.Isso difere do seletor de resultado em uma unir de agrupar não , que não é possível acessar elementos de primeira coleção que não ter nenhuma correspondência na segunda coleção .

O primeiro exemplo neste tópico mostra como executar uma unir de agrupar.O segundo exemplo mostra como usar uma unir de agrupar para criar elementos XML.

Exemplo

Exemplo de junção agrupar

O exemplo a seguir executa uma unir de agrupar de objetos do tipo Person e Pet baseia a Person correspondência de Pet.Owner propriedade. Ao contrário de uma unir de agrupar não que produza um emparelhar de elementos para cada correspondência, a unir de agrupar produz somente um objeto resultante para cada elemento da primeira coleção, que neste exemplo é um Person objeto. Os elementos correspondentes da coleção segundo, que neste exemplo são Pet objetos, são agrupados em uma coleção. Finalmente, a função do seletor de 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:

unir de agrupar para criar o exemplo de XML

Associações de agrupar são ideais para criação de XML usando LINQ to XML. O exemplo a seguir é semelhante ao exemplo anterior, exceto pelo fato de que em vez de criar tipos anônimo, a função de seletor 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 um novo Aplicativo de console projeto em Visual Studio.

  • Adicione uma referência a sistema.Core.dll e sistema.Xml.Linq.dll se eles já não são citados.

  • Incluir o System.Linq e System.Xml.Linq espaços para nome.

  • Copie e cole o código do exemplo no arquivo programa.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 no.

  • Execute o programa.

Consulte também

Tarefas

Como: Executar associações interna (guia de programação translation from VPE for Csharp)

Como: Executar associações externas (guia de programação translation from VPE for Csharp) à esquerda

Conceitos

Junção operações

Tipos anônimos

Referência

Join

GroupJoin

Tipos anônimo (guia de programação translation from VPE for Csharp)

Outros recursos

LINQ to XML