Поделиться через

Join Операции в LINQ

  • Статья

Два join источника данных — это связь объектов в одном источнике данных с объектами, которые совместно используют общий атрибут в другом источнике данных.

Внимание

В этих примерах используется System.Collections.Generic.IEnumerable<T> источник данных. Источники данных, основанные на System.Linq.IQueryProvider использовании System.Linq.IQueryable<T> источников данных и деревьев выражений. Деревья выражений имеют ограничения на допустимый синтаксис C#. Кроме того, каждый IQueryProvider источник данных, например EF Core , может наложить больше ограничений. Ознакомьтесь с документацией по источнику данных.

Присоединение является важной операцией в запросах, предназначенных для источников данных, связи которых друг с другом не могут выполняться напрямую. В объектно-ориентированном программировании присоединение может означать корреляцию между объектами, которые не моделировались, например обратное направление односторонняя связь. Пример односторонняя связь — Student это класс, имеющий свойство типа Department , представляющее основное, но Department класс не имеет свойства, являющегося коллекцией Student объектов. Если у вас есть список Department объектов, и вы хотите найти всех учащихся в каждом отделе, можно использовать join операцию для их поиска.

Методы join , предоставляемые в платформе LINQ, и Join GroupJoin. Они выполняют эквисоединения, или соединения, которые сопоставляют два источника данных на основе равенства их ключей. (Для сравнения Transact-SQL поддерживает join операторы, отличные equalsless than от оператора. В терминах Join реляционной базы данных реализует внутренний joinтипjoin, в котором возвращаются только те объекты, которые имеют совпадение в другом наборе данных. Метод GroupJoin не имеет прямого эквивалента в терминах реляционных баз данных, но реализует надмножество внутренних соединений и левых внешних соединений. Левый внешний join — это join объект, который возвращает каждый элемент первого (левого) источника данных, даже если он не имеет коррелированных элементов в другом источнике данных.

На следующем рисунке показано концептуальное представление двух наборов и элементов в этих наборах, включенных в внутренний join или левый внешний join.

Два перекрывающихся кольца, отображающие внешнее/внутреннее соединение.

Методы

Имя метода Description Синтаксис выражения запроса C# Дополнительные сведения
Join Соединяет две последовательности на основании функций селектора ключа и извлекает пары значений. join … in … on … equals … Enumerable.Join

Queryable.Join
GroupJoin Соединяет две последовательности на основании функций селектора ключа и группирует полученные при сопоставлении данные для каждого элемента. join … in … on … equals … into … Enumerable.GroupJoin

Queryable.GroupJoin

Примечание.

В следующих примерах в этой статье используются общие источники данных для этой области.
Каждый из них Student имеет уровень оценки, основной отдел и ряд показателей. У него Teacher также есть свойство, определяющее City кампус, где учитель проводит классы. У Department него есть имя и ссылка на Teacher того, кто выступает в качестве руководителя отдела.
Пример набора данных можно найти в исходном репозитории.

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; }
}

В следующем примере предложение используется join … in … on … equals … для join двух последовательностей на основе определенного значения:

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}");
}

Предыдущий запрос можно выразить с помощью синтаксиса метода, как показано в следующем коде:

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}");
}

В следующем примере предложение используется join … in … on … equals … into … для join двух последовательностей на основе определенного значения и группирует результирующие совпадения для каждого элемента:

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}");
    }
}

Предыдущий запрос можно выразить с помощью синтаксиса метода, как показано в следующем примере:

// 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}");
    }
}

Выполнение внутренних соединений

В терминах реляционной базы данных внутренний join создает результирующий набор, в котором каждый элемент первой коллекции отображается один раз для каждого соответствующего элемента во второй коллекции. Если элемент в первой коллекции не имеет соответствующих элементов, он не отображается в результирующем наборе. Метод Join , который вызывается предложением join в C#, реализует внутреннюю join. В следующих примерах показано, как выполнить четыре варианта внутреннего join:

  • Простой внутренний join , который сопоставляет элементы из двух источников данных на основе простого ключа.
  • Внутренний join , который сопоставляет элементы из двух источников данных на основе составного ключа. Составной ключ — это ключ, который состоит из нескольких значений, позволяющих сопоставлять элементы на основе сразу нескольких свойств.
  • Несколькоjoin, в которых последовательные join операции добавляются друг к другу.
  • Внутренний join , реализованный с помощью группы join.

Один ключ join

В следующем примере объекты совпадают Teacher с Department объектами, которые TeacherId совпадают с этим Teacher. Предложение select в C# определяет, как выглядят полученные объекты. В следующем примере результирующий объект — это анонимные типы, состоящие из имени отдела и имени преподавателя, который ведет отдел.

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}");
}

Вы достигаете одни и те же результаты с помощью синтаксиса Join метода:

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}");
}

Преподаватели, которые не являются руководителями отделов, не отображаются в окончательных результатах.

Составной ключ join

Вместо сопоставления элементов по одному единственному свойству можно воспользоваться составным ключом и сравнить элементы по нескольким свойствам. Укажите функцию селектора ключей для каждой коллекции, чтобы вернуть анонимный тип, состоящий из свойств, которые требуется сравнить. Если свойства помечаются, они должны иметь одинаковую метку в анонимном типе каждого ключа. Кроме того, свойства должны отображаться в одинаковом порядке.

В следующем примере используется список Teacher объектов и список Student объектов, чтобы определить, какие преподаватели также являются учащимися. Оба этих типа имеют свойства, представляющие имя первого и семейного имени каждого человека. Функции, создающие join ключи из элементов каждого списка, возвращают анонимный тип, состоящий из свойств. Операция join сравнивает эти составные ключи для равенства и возвращает пары объектов из каждого списка, где совпадает имя и имя семейства.

// 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);

Этот Join метод можно использовать, как показано в следующем примере:

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);
}

Многократный join

Любое количество операций join можно добавить друг к другу для выполнения нескольких joinопераций. Каждое join предложение в C# сопоставляет указанный источник данных с результатами предыдущего join.

Первое join предложение соответствует учащимся и отделам на Student основе сопоставления Department объекта DepartmentID ID. Он возвращает последовательность анонимных типов, содержащих Student объект и Department объект.

Второе join предложение сопоставляет анонимные типы, возвращаемые первым join , с Teacher объектами на основе идентификатора этого преподавателя, соответствующего идентификатору руководителя отдела. Он возвращает последовательность анонимных типов, содержащих имя учащегося, имя отдела и имя руководителя отдела. Так как эта операция является внутренней join, возвращаются только те объекты из первого источника данных, которые имеют совпадение во втором источнике данных.

// 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}".""");
}

Эквивалент, использующий несколько методов, использует один и Join тот же подход с анонимным типом:

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}".""");
}

Внутренний join с помощью сгруппированных join

В следующем примере показано, как реализовать внутреннюю join с помощью группы join. Список Department объектов присоединен к списку Student объектов на Department.ID основе сопоставления Student.DepartmentID свойства. Группа join создает коллекцию промежуточных групп, где каждая группа состоит из Department объекта и последовательности соответствующих Student объектов. Второе from предложение объединяет (или плоские) эту последовательность последовательностей в одну длинную последовательность. Предложение select указывает тип элементов в конечной последовательности. Этот тип является анонимным типом, состоящим из имени учащегося и соответствующего имени отдела.

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}");
}

Те же результаты можно достичь с помощью GroupJoin метода, как показано ниже.

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}");
}

Результат эквивалентен результирующему набору, полученному с помощью join предложения без into предложения для выполнения внутреннего join. Следующий код демонстрирует этот эквивалентный запрос:

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}");
}

Чтобы избежать цепочки, можно использовать один Join метод, как показано здесь:

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}");
}

Выполнение групповых соединений

Группа join полезна для создания иерархических структур данных. Каждый элемент из первой коллекции группируется с набором соответствующих элементов из второй коллекции.

Примечание.

Каждый элемент первой коллекции отображается в результирующем наборе группы join независимо от того, найдены ли коррелированные элементы во второй коллекции. В случае, если такие элементы не найдены, последовательность соответствующих элементов будет пуста. Селектор результата имеет доступ к каждому элементу первой коллекции. Это отличается от селектора результатов в негрупповой группе join, которая не может получить доступ к элементам из первой коллекции, которая не соответствует второй коллекции.

Предупреждение

Метод Enumerable.GroupJoin не имеет прямого эквивалента в традиционных терминах реляционных баз данных. Однако он реализует расширенный набор внутренних соединений и левых внешних соединений. Обе эти операции могут быть записаны с точки зрения сгруппированных join. Дополнительные сведения см. в разделе Entity Framework Core. GroupJoin

В первом примере в этой статье показано, как выполнить группу join. Во втором примере показано, как использовать группу join для создания XML-элементов.

Группа join

В следующем примере выполняется группа join объектов типа Department и Student на Department.ID основе соответствующего Student.DepartmentID свойства. В отличие от группы join, которая создает пару элементов для каждого совпадения, группа join создает только один результирующий объект для каждого элемента первой коллекции, который в этом примере является Department объектом. Соответствующие элементы из второй коллекции (в данном примере — объекты Student) группируются в коллекцию. Наконец, результирующая функция селектора создает для каждого совпадения анонимный тип, состоящий из Department.Name и коллекции объектов Student.

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}");
    }
}

В приведенном выше примере query переменная содержит запрос, который создает список, в котором каждый элемент является анонимным типом, содержащим имя отдела и коллекцию учащихся, изучающих этот отдел.

Эквивалентный запрос с использованием синтаксиса метода показан в следующем коде:

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}");
    }
}

Группа join для создания XML

Групповые соединения идеально подходят для создания XML с помощью LINQ to XML. Приведенный ниже пример аналогичен предыдущему за исключением того, что вместо создания анонимных типов результирующая функция селектора создает XML-элементы, представляющие соединенные объекты.

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);

Эквивалентный запрос с использованием синтаксиса метода показан в следующем коде:

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);

Выполнение левых внешних соединений

Левый внешний join — это join элемент, в котором возвращается каждый элемент первой коллекции, независимо от того, имеет ли он какие-либо коррелированные элементы во второй коллекции. Для выполнения левого внешнего элемента join можно использовать LINQ, вызвав DefaultIfEmpty метод в результатах группы join.

В следующем примере показано, как использовать DefaultIfEmpty метод в результатах группы join для выполнения левого внешнего joinвида.

Первым шагом в создании левой внешней join части двух коллекций является выполнение внутреннего join с помощью группы join. (См. раздел Выполните внутренние соединения для объяснения этого процесса.) В этом примере список Department объектов присоединяется к списку Student объектов на Department основе идентификатора объекта, соответствующего учащемуся DepartmentID.

Вторым шагом является включение каждого элемента первой (левой) коллекции в набор результатов, даже если элемент не имеет совпадений в правой коллекции. Это достигается путем вызова DefaultIfEmpty каждой последовательности соответствующих элементов из группы join. В этом примере DefaultIfEmpty вызывается для каждой последовательности совпадающих объектов Student. Метод возвращает коллекцию, содержащую одно значение по умолчанию, если последовательность соответствующих Student объектов пуста для любого Department объекта, гарантируя, что каждый Department объект представлен в коллекции результатов.

Примечание.

Значение по умолчанию для ссылочного типа — null, поэтому в примере проверяется пустая ссылка перед доступом к каждому элементу в каждой коллекции Student.

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}");
}

Эквивалентный запрос с использованием синтаксиса метода показан в следующем коде:

var query = students.GroupJoin(departments, student => student.DepartmentID, department => department.ID,
    (student, departmentList) => new { student, subgroup = departmentList.AsQueryable() })
    .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}");
}

См. также