Ошибки и их решения

LEFT OUTER JOIN в LINQ: как объединить коллекции в C#

4 мин чтения

LEFT OUTER JOIN в LINQ возвращает все элементы левой коллекции и подставляет к ним совпадения из правой, а при отсутствии пары оставляет null. Прямого оператора для этого в запросах нет, поэтому используют связку join, into и DefaultIfEmpty. Ниже показаны оба синтаксиса, полный пример и способы обойти типичные проблемы.

LEFT OUTER JOIN в LINQ: как объединить коллекции в C#
Содержание
  1. Что такое LEFT OUTER JOIN и зачем он нужен
  2. Синтаксис LEFT OUTER JOIN в LINQ
  3. Пример: сотрудники и отделы
  4. Обработка null при LEFT OUTER JOIN
  5. Метод LeftJoin в новых версиях .NET
  6. Преимущества и недостатки
  7. Как ускорить запросы с LEFT OUTER JOIN
  8. Частые вопросы

Что такое LEFT OUTER JOIN и зачем он нужен

LEFT OUTER JOIN - это тип объединения таблиц или коллекций, при котором результат включает все записи слева и найденные для них записи справа. Если совпадения нет, вместо правой записи в результате будет null.

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

Синтаксис LEFT OUTER JOIN в LINQ

В синтаксисе запросов используется join с ключевым словом into, которое собирает совпадения в группу, а затем вторая конструкция from разворачивает группу с помощью DefaultIfEmpty(). Если группа пуста, метод возвращает один элемент со значением по умолчанию, то есть null для ссылочных типов.

var query = from left in leftCollection
            join right in rightCollection on left.Key equals right.Key into temp
            from right in temp.DefaultIfEmpty()
            select new { left, right };

Тот же запрос в синтаксисе методов расширения строится из методов GroupJoin и SelectMany. GroupJoin формирует для каждого левого элемента группу совпадений, а SelectMany разворачивает эту группу в плоский список:

var query = leftCollection
    .GroupJoin(
        rightCollection,
        left => left.Key,
        right => right.Key,
        (left, rightGroup) => new { left, rightGroup })
    .SelectMany(
        x => x.rightGroup.DefaultIfEmpty(),
        (x, right) => new { x.left, right });

Пример: сотрудники и отделы

Возьмём две коллекции: список сотрудников и список отделов. У сотрудника идентификатор отдела может быть пустым, поэтому поле объявлено как int?.

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public int? DepartmentId { get; set; }
}

public class Department
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
}

List<Employee> employees = new()
{
    new Employee { Id = 1, Name = "Alice", DepartmentId = 1 },
    new Employee { Id = 2, Name = "Bob", DepartmentId = null }, // Bob не принадлежит ни одному отделу
    new Employee { Id = 3, Name = "Carol", DepartmentId = 2 }
};

List<Department> departments = new()
{
    new Department { Id = 1, Name = "HR" },
    new Department { Id = 2, Name = "IT" },
    new Department { Id = 3, Name = "Sales" }
};

Теперь объединим коллекции так, чтобы в результат попали все сотрудники, а название отдела подставлялось только при наличии пары:

var employeeWithDepartment = from employee in employees
                             join department in departments on employee.DepartmentId equals department.Id into deptGroup
                             from department in deptGroup.DefaultIfEmpty()
                             select new
                             {
                                 EmployeeName = employee.Name,
                                 DepartmentName = department?.Name ?? "No Department"
                             };

foreach (var item in employeeWithDepartment)
{
    Console.WriteLine($"{item.EmployeeName}: {item.DepartmentName}");
}
// Alice: HR
// Bob: No Department
// Carol: IT

Отдел Sales в результат не попал, потому что он находится в правой коллекции и сотрудников в нём нет. Именно так отличается LEFT OUTER JOIN от полного внешнего соединения.

Обработка null при LEFT OUTER JOIN

После DefaultIfEmpty правый элемент может быть null, и обращение к его полям без проверки вызовет NullReferenceException. В примере выше для этого использованы оператор условного доступа ?. и оператор объединения с null ??. Если пары нет, подставляется строка "No Department".

Для значимых типов поведение другое: DefaultIfEmpty() вернёт значение по умолчанию, например 0, и отличить его от настоящего нуля будет нельзя. В таком случае лучше объединять сущности-классы или перегрузкой DefaultIfEmpty(значение) задать своё значение для отсутствующей записи.

Метод LeftJoin в новых версиях .NET

Связка GroupJoin, SelectMany и DefaultIfEmpty долго оставалась единственным способом выразить левое соединение в запросах по методам. В .NET 10 и EF Core 10 появились готовые операторы LeftJoin и RightJoin, которые делают запрос короче и понятнее.

var result = employees.LeftJoin(
    departments,
    e => e.DepartmentId,
    d => d.Id,
    (e, d) => new { e.Name, Department = d?.Name ?? "No Department" });

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

Преимущества и недостатки

Левое соединение позволяет собрать данные из нескольких источников, не теряя строки основной коллекции, и строить отчёты с необязательными связями. Запросы читаются хорошо, пока в них одно-два соединения.

Недостатки связаны со сложностью и скоростью. Конструкция из join, into и DefaultIfEmpty выглядит громоздко, а при больших объёмах данных вложенные соединения заметно нагружают память и процессор.

Как ускорить запросы с LEFT OUTER JOIN

Если данные берутся из базы через Entity Framework, такой запрос переводится в SQL LEFT JOIN, и скорость во многом зависит от индексов на столбцах соединения. Для коллекций в памяти полезно один раз построить словарь или ToLookup по ключу правой коллекции, тогда поиск пары не будет перебирать весь список для каждого элемента.

Стоит также следить за структурой данных, которые вы выбираете: в результат нужно брать только нужные поля, а не целые объекты. Так через сеть и в память не пересылается лишняя информация.

Частые вопросы

Чем LEFT OUTER JOIN отличается от обычного join в LINQ?

Обычный join в LINQ работает как INNER JOIN: в результат попадают только элементы, у которых нашлась пара. LEFT OUTER JOIN сохраняет все элементы левой коллекции, а для отсутствующих пар возвращает null или значение по умолчанию.

Зачем нужен DefaultIfEmpty?

GroupJoin создаёт для каждого левого элемента группу совпадений, и для элемента без пары группа пустая. Если развернуть пустую группу напрямую, элемент исчезнет из результата. DefaultIfEmpty заменяет пустую группу одним элементом со значением по умолчанию, поэтому левая запись сохраняется.

Как сделать RIGHT OUTER JOIN в LINQ?

Нужно поменять коллекции местами: правой становится та, где надо сохранить все записи. В новых версиях .NET для этого есть и готовый метод RightJoin. Полное внешнее соединение собирают как объединение левого и правого соединений через Union.

Работает ли тот же запрос с Entity Framework?

Да, поставщик переводит конструкцию join, into и DefaultIfEmpty в SQL LEFT JOIN. Оператор ?. внутри проекции тоже обычно переводится корректно. Если запрос получился слишком сложным, посмотрите итоговый SQL и при необходимости упростите его.