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

Join Операции в LINQ

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

Внимание

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

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

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

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

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

Методы

Имя метода Описание Синтаксис выражения запроса 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 … для объединения двух последовательностей на основе определенного значения.

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 … используется для объединения двух последовательностей на основе определенного значения и группировки совпадений, полученных для каждого элемента.

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 в C#, реализует внутреннее соединение. В следующих примерах показано, как выполнить четыре варианта внутреннего соединения:

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

Соединение с одним ключом

В следующем примере объекты совпадают 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}");
}

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

Составное соединение ключей

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

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

// 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 предложение в C# сопоставляет указанный источник данных с результатами предыдущего соединения.

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

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

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

Внутреннее соединение с помощью сгруппированного соединения

В следующем примере показано, как реализовать внутреннее соединение с помощью соединения группы. Список Department объектов присоединен к списку Student объектов на Department.ID основе сопоставления Student.DepartmentID свойства. Соединение группы создает коллекцию промежуточных групп, где каждая группа состоит из 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 для выполнения внутреннего соединения. Следующий код демонстрирует этот эквивалентный запрос:

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

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

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

Примечание.

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

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

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

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

Присоединение к группе

В следующем примере выполняется групповое объединение объектов типа Department и Student на основе сопоставления свойства Department.ID с Student.DepartmentID. В отличие от негруппового соединения, которое создает пару элементов для каждого совпадения, групповое соединение создает только один результирующий объект для каждого элемента первой коллекции (в данном примере это объект 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}");
    }
}

Объединение групп для создания 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);

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

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

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

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

Вторым шагом является включение каждого элемента первой (левой) коллекции в набор результатов, даже если элемент не имеет совпадений в правой коллекции. Это достигается путем вызова DefaultIfEmpty для каждой последовательности соответствующих элементов из группового соединения. В этом примере 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 })
    .SelectMany(
        joinedSet => joinedSet.subgroup.DefaultIfEmpty(),
        (student, department) => new
        {
            student.student.FirstName,
            student.student.LastName,
            Department = department?.Name ?? string.Empty
        });

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

См. также