Join Operações em LINQ

Uma join de duas fontes de dados é a associação de objetos em uma fonte de dados com objetos que compartilham um atributo comum em outra fonte de dados.

A junção é uma operação importante em consultas que visam fontes de dados cujas relações entre si não podem ser seguidas diretamente. Na programação orientada a objetos, a junção pode significar uma correlação entre objetos que não é modelada, como a direção para trás de uma relação unidirecional. Um exemplo de uma relação unidirecional é uma Student classe que tem uma propriedade do tipo Department que representa a principal, mas a Department classe não tem uma propriedade que é uma coleção de Student objetos. Se você tiver uma lista de Department objetos e quiser encontrar todos os alunos em cada departamento, você pode usar uma join operação para encontrá-los.

Os join métodos fornecidos na estrutura LINQ são Join e GroupJoin. Esses métodos executam equijunções ou junções que correspondem a duas fontes de dados com base na igualdade de suas chaves. (Para comparação, o Transact-SQL oferece suporte a join operadores diferentes de equals, por exemplo, o less than operador.) Em termos de banco de dados relacional, Join implementa um , um jointipo interno no qual apenas os objetos que têm uma correspondência no outro conjunto de join dados são retornados. O GroupJoin método não tem equivalente direto em termos de banco de dados relacional, mas implementa um superconjunto de junções internas e externas esquerdas. Um externo join esquerdo é um join que retorna cada elemento da primeira fonte de dados (esquerda), mesmo que não tenha elementos correlacionados na outra fonte de dados.

A ilustração a seguir mostra uma visão conceitual de dois conjuntos e os elementos dentro desses conjuntos que estão incluídos em um externo joininterno join ou esquerdo.

Métodos

public enum GradeLevel
{
    FirstYear = 1,
    SecondYear,
    ThirdYear,
    FourthYear
};

public class Student
{
    public required string FirstName { get; init; }
    public required string LastName { get; init; }
    public required int ID { get; init; }

    public required GradeLevel Year { get; init; }
    public required List<int> Scores { get; init; }

    public required int DepartmentID { get; init; }
}

public class Teacher
{
    public required string First { get; init; }
    public required string Last { get; init; }
    public required int ID { get; init; }
    public required string City { get; init; }
}

public class Department
{
    public required string Name { get; init; }
    public int ID { get; init; }

    public required int TeacherID { get; init; }
}

O exemplo a seguir usa a join … in … on … equals … cláusula para join duas sequências com base no valor específico:

var query = from student in students
            join department in departments on student.DepartmentID equals department.ID
            select new { Name = $"{student.FirstName} {student.LastName}", DepartmentName = department.Name };

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} - {item.DepartmentName}");
}

A consulta anterior pode ser expressa usando a sintaxe do método, conforme mostrado no código a seguir:

var query = students.Join(departments,
    student => student.DepartmentID, department => department.ID,
    (student, department) => new { Name = $"{student.FirstName} {student.LastName}", DepartmentName = department.Name });

foreach (var item in query)
{
    Console.WriteLine($"{item.Name} - {item.DepartmentName}");
}

O exemplo a seguir usa a join … in … on … equals … into … cláusula para join duas sequências com base em valor específico e agrupa as correspondências resultantes para cada elemento:

IEnumerable<IEnumerable<Student>> studentGroups = from department in departments
                    join student in students on department.ID equals student.DepartmentID into studentGroup
                    select studentGroup;

foreach (IEnumerable<Student> studentGroup in studentGroups)
{
    Console.WriteLine("Group");
    foreach (Student student in studentGroup)
    {
        Console.WriteLine($"  - {student.FirstName}, {student.LastName}");
    }
}

A consulta anterior pode ser expressa usando a sintaxe do método, conforme mostrado no exemplo a seguir:

// Join department and student based on DepartmentId and grouping result
IEnumerable<IEnumerable<Student>> studentGroups = departments.GroupJoin(students,
    department => department.ID, student => student.DepartmentID,
    (department, studentGroup) => studentGroup);

foreach (IEnumerable<Student> studentGroup in studentGroups)
{
    Console.WriteLine("Group");
    foreach (Student student in studentGroup)
    {
        Console.WriteLine($"  - {student.FirstName}, {student.LastName}");
    }
}

Executar junções internas

Em termos de banco de dados relacional, um interno join produz um conjunto de resultados no qual cada elemento da primeira coleção aparece uma vez para cada elemento correspondente na segunda coleção. Se um elemento na primeira coleção não tiver elementos correspondentes, ele não aparecerá no conjunto de resultados. O Join método, que é chamado pela join cláusula em C#, implementa um .join Os exemplos a seguir mostram como executar quatro variações de um interior join:

• Um interno join simples que correlaciona elementos de duas fontes de dados com base em uma chave simples.
• Um interno join que correlaciona elementos de duas fontes de dados com base em uma chave composta . Uma chave composta, que é uma chave que consiste em mais de um valor, permite correlacionar elementos com base em mais de uma propriedade.
• Um múltiplo join no qual operações sucessivas join são anexadas umas às outras.
• Um interno join que é implementado usando um grupo join.

Chave única join

O exemplo a seguir corresponde a Teacher objetos com Department objetos cujos TeacherId correspondem a .Teacher A select cláusula em C# define a aparência dos objetos resultantes. No exemplo a seguir, os objetos resultantes são tipos anônimos que consistem no nome do departamento e no nome do professor que lidera o departamento.

var query = from department in departments
            join teacher in teachers on department.TeacherID equals teacher.ID
            select new
            {
                DepartmentName = department.Name,
                TeacherName = $"{teacher.First} {teacher.Last}"
            };

foreach (var departmentAndTeacher in query)
{
    Console.WriteLine($"{departmentAndTeacher.DepartmentName} is managed by {departmentAndTeacher.TeacherName}");
}

Você obtém os mesmos resultados usando a sintaxe do Join método:

var query = teachers
    .Join(departments, teacher => teacher.ID, department => department.TeacherID,
        (teacher, department) =>
        new { DepartmentName = department.Name, TeacherName = $"{teacher.First} {teacher.Last}" });

foreach (var departmentAndTeacher in query)
{
    Console.WriteLine($"{departmentAndTeacher.DepartmentName} is managed by {departmentAndTeacher.TeacherName}");
}

Os professores que não são chefes de departamento não aparecem nos resultados finais.

Chave composta join

Em vez de correlacionar elementos com base em apenas uma propriedade, você pode usar uma chave composta para comparar elementos com base em várias propriedades. Especifique a função seletora de chave para cada coleção para retornar um tipo anônimo que consiste nas propriedades que você deseja comparar. Se você rotular as propriedades, elas deverão ter o mesmo rótulo no tipo anônimo de cada chave. As propriedades também devem aparecer na mesma ordem.

O exemplo a seguir usa uma lista de Teacher objetos e uma lista de Student objetos para determinar quais professores também são alunos. Ambos os tipos têm propriedades que representam o primeiro nome e o nome de família de cada pessoa. As funções que criam as chaves a join partir dos elementos de cada lista retornam um tipo anônimo que consiste nas propriedades. A join operação compara essas chaves compostas para igualdade e retorna pares de objetos de cada lista onde o primeiro nome e o nome da família coincidem.

// 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 teacher in teachers
    join student in students on new
    {
        FirstName = teacher.First,
        LastName = teacher.Last
    } equals new
    {
        student.FirstName,
        student.LastName
    }
    select teacher.First + " " + teacher.Last;

string result = "The following people are both teachers and students:\r\n";
foreach (string name in query)
{
    result += $"{name}\r\n";
}
Console.Write(result);

Você pode usar o Join método, conforme mostrado no exemplo a seguir:

IEnumerable<string> query = teachers
    .Join(students,
        teacher => new { FirstName = teacher.First, LastName = teacher.Last },
        student => new { student.FirstName, student.LastName },
        (teacher, student) => $"{teacher.First} {teacher.Last}"
 );

Console.WriteLine("The following people are both teachers and students:");
foreach (string name in query)
{
    Console.WriteLine(name);
}

Múltiplos join

Qualquer número de operações pode ser anexado join entre si para executar um múltiplo join. Cada join cláusula em C# correlaciona uma fonte de dados especificada com os resultados do arquivo join.

A primeira join cláusula corresponde a alunos e departamentos com base na correspondência Department de DepartmentID um Student objeto com o ID. Ele retorna uma sequência de tipos anônimos que contêm o objeto e Department o Student objeto.

A segunda join cláusula correlaciona os tipos anônimos retornados pelo primeiro join com Teacher objetos baseados no ID do professor correspondente ao ID do chefe de departamento. Ele retorna uma sequência de tipos anônimos que contêm o nome do aluno, o nome do departamento e o nome do líder do departamento. Como essa operação é interna join, somente os objetos da primeira fonte de dados que têm uma correspondência na segunda fonte de dados são retornados.

// The first join matches Department.ID and Student.DepartmentID from the list of students and
// departments, based on a common ID. The second join matches teachers who lead departments
// with the students studying in that department.
var query = from student in students
    join department in departments on student.DepartmentID equals department.ID
    join teacher in teachers on department.TeacherID equals teacher.ID
    select new {
        StudentName = $"{student.FirstName} {student.LastName}",
        DepartmentName = department.Name,
        TeacherName = $"{teacher.First} {teacher.Last}"
    };

foreach (var obj in query)
{
    Console.WriteLine($"""The student "{obj.StudentName}" studies in the department run by "{obj.TeacherName}".""");
}

O equivalente usando o método múltiplo Join usa a mesma abordagem com o tipo anônimo:

var query = students
    .Join(departments, student => student.DepartmentID, department => department.ID,
        (student, department) => new { student, department })
    .Join(teachers, commonDepartment => commonDepartment.department.TeacherID, teacher => teacher.ID,
        (commonDepartment, teacher) => new
        {
            StudentName = $"{commonDepartment.student.FirstName} {commonDepartment.student.LastName}",
            DepartmentName = commonDepartment.department.Name,
            TeacherName = $"{teacher.First} {teacher.Last}"
        });

foreach (var obj in query)
{
    Console.WriteLine($"""The student "{obj.StudentName}" studies in the department run by "{obj.TeacherName}".""");
}

Interior join usando agrupado join

O exemplo a seguir mostra como implementar um interno join usando um grupo join. A lista de objetos é unida Department ao grupo à lista de Student objetos com base na Department.ID correspondência da Student.DepartmentID propriedade. O grupo join cria uma coleção de grupos intermediários, onde cada grupo consiste em um Department objeto e uma sequência de objetos correspondentes Student . A segunda from cláusula combina (ou nivela) esta sequência de sequências numa sequência mais longa. A select cláusula especifica o tipo de elementos na sequência final. Esse tipo é um tipo anônimo que consiste no nome do aluno e no nome do departamento correspondente.

var query1 =
    from department in departments
    join student in students on department.ID equals student.DepartmentID into gj
    from subStudent in gj
    select new
    {
        DepartmentName = department.Name,
        StudentName = $"{subStudent.FirstName} {subStudent.LastName}"
    };
Console.WriteLine("Inner join using GroupJoin():");
foreach (var v in query1)
{
    Console.WriteLine($"{v.DepartmentName} - {v.StudentName}");
}

Os mesmos resultados podem ser alcançados usando GroupJoin o método, como se segue:

var queryMethod1 = departments
    .GroupJoin(students, department => department.ID, student => student.DepartmentID,
        (department, gj) => new { department, gj })
    .SelectMany(departmentAndStudent => departmentAndStudent.gj,
        (departmentAndStudent, subStudent) => new
        {
            DepartmentName = departmentAndStudent.department.Name,
            StudentName = $"{subStudent.FirstName} {subStudent.LastName}"
        });

Console.WriteLine("Inner join using GroupJoin():");
foreach (var v in queryMethod1)
{
    Console.WriteLine($"{v.DepartmentName} - {v.StudentName}");
}

O resultado é equivalente ao conjunto de resultados obtido usando a join cláusula sem a into cláusula para executar um .join O código a seguir demonstra essa consulta equivalente:

var query2 = from department in departments
    join student in students on department.ID equals student.DepartmentID
    select new
    {
        DepartmentName = department.Name,
        StudentName = $"{student.FirstName} {student.LastName}"
    };

Console.WriteLine("The equivalent operation using Join():");
foreach (var v in query2)
{
    Console.WriteLine($"{v.DepartmentName} - {v.StudentName}");
}

Para evitar o encadeamento, o método único Join pode ser usado como apresentado aqui:

var queryMethod2 = departments.Join(students, departments => departments.ID, student => student.DepartmentID,
    (department, student) => new
    {
        DepartmentName = department.Name,
        StudentName = $"{student.FirstName} {student.LastName}"
    });

Console.WriteLine("The equivalent operation using Join():");
foreach (var v in queryMethod2)
{
    Console.WriteLine($"{v.DepartmentName} - {v.StudentName}");
}

Executar junções agrupadas

O grupo join é útil para produzir estruturas de dados hierárquicas. Emparelha cada elemento da primeira coleção com um conjunto de elementos correlacionados da segunda coleção.

O primeiro exemplo neste artigo mostra como executar um grupo join. O segundo exemplo mostra como usar um grupo join para criar elementos XML.

Grupo join

O exemplo a seguir executa um grupo join de objetos do tipo Department e Student com base na Department.ID correspondência da Student.DepartmentID propriedade. Ao contrário de um não-grupo join, que produz um par de elementos para cada correspondência, o grupo join produz apenas um objeto resultante para cada elemento da primeira coleção, que neste exemplo é um Department objeto. Os elementos correspondentes da segunda coleção, que neste exemplo são Student objetos, são agrupados em uma coleção. Finalmente, a função seletor de resultados cria um tipo anônimo para cada correspondência que consiste em Department.Name e uma coleção de Student objetos.

var query = from department in departments
    join student in students on department.ID equals student.DepartmentID into studentGroup
    select new
    {
        DepartmentName = department.Name,
        Students = studentGroup
    };

foreach (var v in query)
{
    // Output the department's name.
    Console.WriteLine($"{v.DepartmentName}:");

    // Output each of the students in that department.
    foreach (Student? student in v.Students)
    {
        Console.WriteLine($"  {student.FirstName} {student.LastName}");
    }
}

No exemplo acima, query a variável contém a consulta que cria uma lista onde cada elemento é um tipo anônimo que contém o nome do departamento e uma coleção de alunos que estudam nesse departamento.

A consulta equivalente usando sintaxe de método é mostrada no código a seguir:

var query = departments.GroupJoin(students, department => department.ID, student => student.DepartmentID,
    (department, Students) => new { DepartmentName = department.Name, Students });

foreach (var v in query)
{
    // Output the department's name.
    Console.WriteLine($"{v.DepartmentName}:");

    // Output each of the students in that department.
    foreach (Student? student in v.Students)
    {
        Console.WriteLine($"  {student.FirstName} {student.LastName}");
    }
}

Grupo join para criar XML

As junções de grupo são ideais para criar XML usando LINQ to XML. O exemplo a seguir é semelhante ao exemplo anterior, exceto que, em vez de criar tipos anônimos, a função seletor de resultados cria elementos XML que representam os objetos associados.

XElement departmentsAndStudents = new("DepartmentEnrollment",
    from department in departments
    join student in students on department.ID equals student.DepartmentID into studentGroup
    select new XElement("Department",
        new XAttribute("Name", department.Name),
        from student in studentGroup
        select new XElement("Student",
            new XAttribute("FirstName", student.FirstName),
            new XAttribute("LastName", student.LastName)
        )
    )
);

Console.WriteLine(departmentsAndStudents);

A consulta equivalente usando sintaxe de método é mostrada no código a seguir:

XElement departmentsAndStudents = new("DepartmentEnrollment",
    departments.GroupJoin(students, department => department.ID, student => student.DepartmentID,
        (department, Students) => new XElement("Department",
            new XAttribute("Name", department.Name),
            from student in Students
            select new XElement("Student",
                new XAttribute("FirstName", student.FirstName),
                new XAttribute("LastName", student.LastName)
            )
        )
    )
);

Console.WriteLine(departmentsAndStudents);

Executar junções externas à esquerda

Um exterior join esquerdo é um join elemento no qual cada elemento da primeira coleção é retornado, independentemente de ter ou não elementos correlacionados na segunda coleção. Você pode usar o LINQ para executar um externo join esquerdo chamando o DefaultIfEmpty método nos resultados de um grupo join.

O exemplo a seguir demonstra como usar o DefaultIfEmpty método nos resultados de um grupo join para executar um externo joinesquerdo .

O primeiro passo para produzir um exterior join esquerdo de duas coleções é executar um interior join usando um grupo join. (Ver Execute junções internas para uma explicação desse processo.) Neste exemplo, a lista de Department objetos é associada à lista de Student objetos com base na ID de um Department objeto que corresponde à do aluno DepartmentID.

A segunda etapa é incluir cada elemento da primeira coleção (esquerda) no conjunto de resultados, mesmo que esse elemento não tenha correspondências na coleção correta. Isso é feito chamando DefaultIfEmpty cada sequência de elementos correspondentes do grupo join. Neste exemplo, DefaultIfEmpty é chamado em cada sequência de objetos correspondentes Student . O método retorna uma coleção que contém um único valor padrão se a sequência de objetos correspondentes Student estiver vazia para qualquer Department objeto, garantindo que cada Department objeto seja representado na coleção de resultados.

var query =
    from student in students
    join department in departments on student.DepartmentID equals department.ID into gj
    from subgroup in gj.DefaultIfEmpty()
    select new
    {
        student.FirstName,
        student.LastName,
        Department = subgroup?.Name ?? string.Empty
    };

foreach (var v in query)
{
    Console.WriteLine($"{v.FirstName:-15} {v.LastName:-15}: {v.Department}");
}

A consulta equivalente usando sintaxe de método é mostrada no código a seguir:

var query = students
    .GroupJoin(
        departments,
        student => student.DepartmentID,
        department => department.ID,
        (student, departmentList) => new { student, subgroup = departmentList })
    .SelectMany(
        joinedSet => joinedSet.subgroup.DefaultIfEmpty(),
        (student, department) => new
        {
            student.student.FirstName,
            student.student.LastName,
            Department = department.Name
        });

foreach (var v in query)
{
    Console.WriteLine($"{v.FirstName:-15} {v.LastName:-15}: {v.Department}");
}

Consulte também

• Join
• GroupJoin
• Tipos anónimos
• Formular junções e consultas entre produtos
• join cláusula
• Cláusula de grupo
• Como conteúdo join de arquivos diferentes (LINQ) (C#)
• Como preencher coleções de objetos de várias fontes (LINQ) (C#)