Join Operações em LINQ
Uma junção 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.
JoinO ing é 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 objetos e quiser encontrar todos os alunos em cada departamento, você pode usar uma operação de Department junção para encontrá-los.
Os métodos de junção 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 operadores de junção diferentes de equals, por exemplo, o less than operador.) Em termos de banco de dados relacional, Join implementa uma junção interna, um tipo de junção na qual apenas os objetos que têm uma correspondência no outro conjunto de 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. Uma junção externa esquerda é uma junção 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 uma junção interna ou externa.
Métodos
| Nome do método | Description | Sintaxe da expressão de consulta C# | Mais Informações |
|---|---|---|---|
| Join | Joins duas sequências baseadas em funções seletoras de teclas e extrai pares de valores. | join … in … on … equals … |
Enumerable.Join Queryable.Join |
| GroupJoin | Joins duas sequências baseadas em funções seletoras de teclas e agrupa as correspondências resultantes para cada elemento. | join … in … on … equals … into … |
Enumerable.GroupJoin Queryable.GroupJoin |
Os exemplos a seguir neste artigo usam as fontes de dados comuns para essa área:
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; }
}
Cada Student um tem um nível de nota, um departamento primário e uma série de pontuações. A Teacher também tem uma City propriedade que identifica o campus onde o professor tem aulas. A Department tem um nome, e uma referência a um Teacher que serve como chefe de departamento.
O exemplo a seguir usa a join … in … on … equals … cláusula para unir duas sequências com base em 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 unir 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, uma junção interna 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 uma junção interna. Os exemplos a seguir mostram como executar quatro variações de uma junção interna:
- Uma junção interna simples que correlaciona elementos de duas fontes de dados com base em uma chave simples.
- Uma junção interna 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.
- Uma junção múltipla na qual operações de junção sucessivas são anexadas umas às outras.
- Uma associação interna que é implementada usando uma associação de grupo.
Junção de chave única
O exemplo a seguir corresponde a Teacher objetos com Deparment 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.
Junção de chave composta
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 de junção dos elementos de cada lista retornam um tipo anônimo que consiste nas propriedades. A operação de junçã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);
}
Junção múltipla
Qualquer número de operações de junção pode ser anexado entre si para executar uma junção múltipla. Cada join cláusula em C# correlaciona uma fonte de dados especificada com os resultados da junção anterior.
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 pela primeira junção 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 é uma junção interna, 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}".""");
}
Junção interna usando associação agrupada
O exemplo a seguir mostra como implementar uma associação interna usando uma associação de grupo. A lista de objetos é unida Department ao grupo à lista de Student objetos com base na Department.ID correspondência da Student.DepartmentID propriedade. A junção de grupo 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 realizar uma junção interna. 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
A junção de grupo é ú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.
Nota
Cada elemento da primeira coleção aparece no conjunto de resultados de uma junção de grupo, independentemente de os elementos correlacionados serem encontrados na segunda coleção. No caso em que nenhum elemento correlacionado é encontrado, a sequência de elementos correlacionados para esse elemento é vazia. O seletor de resultados tem, portanto, acesso a todos os elementos da primeira coleção. Isso difere do seletor de resultados em uma associação que não seja de grupo, que não pode acessar elementos da primeira coleção que não têm correspondência na segunda coleção.
Aviso
Enumerable.GroupJoin não tem equivalente direto em termos de banco de dados relacional tradicional. No entanto, esse método implementa um superconjunto de junções internas e externas esquerdas. Ambas as operações podem ser escritas em termos de uma junção agrupada. Para obter mais informações, consulte Entity Framework Core, GroupJoin.
O primeiro exemplo neste artigo mostra como realizar uma associação de grupo. O segundo exemplo mostra como usar uma associação de grupo para criar elementos XML.
Adesão ao grupo
O exemplo a seguir executa uma junção de grupo de objetos do tipo Department e Student com base na Deoartment.ID correspondência da Student.DepartmentID propriedade. Ao contrário de uma junção não grupo, que produz um par de elementos para cada correspondência, a junção de grupo 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}");
}
}
Ingressar em grupo 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
Uma junção externa esquerda é uma junção na qual cada elemento da primeira coleção é retornado, independentemente de ter quaisquer elementos correlacionados na segunda coleção. Você pode usar o LINQ para executar uma junção externa esquerda chamando o DefaultIfEmpty método nos resultados de uma associação de grupo.
O exemplo a seguir demonstra como usar o DefaultIfEmpty método nos resultados de uma junção de grupo para executar uma junção externa esquerda.
A primeira etapa na produção de uma junção externa esquerda de duas coleções é executar uma junção interna usando uma junção de grupo. (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 da junção do grupo. 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.
Nota
O valor padrão para um tipo de referência é null; portanto, o exemplo verifica se há uma referência nula antes de acessar cada elemento de cada Student coleção.
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, department) => new { student, subgroup = department.DefaultIfEmpty() })
.Select(gj => new
{
gj.student.FirstName,
gj.student.LastName,
Department = gj.subgroup?.FirstOrDefault()?.Name ?? string.Empty
});
foreach (var v in query)
{
Console.WriteLine($"{v.FirstName:-15} {v.LastName:-15}: {v.Department}");
}
Consulte também
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários