Как подгрузишь много зависимых сущностей?

Загрузка множества зависимых сущностей в C#

При работе с ORM (Object-Relational Mapping) и Entity Framework Core, загрузка множества связанных сущностей является частой задачей, требующей баланса между производительностью и удобством.

Основные стратегии загрузки зависимых данных

1. Явная загрузка (Explicit Loading)

Метод .Include() позволяет заранее указать связанные сущности в одном запросе, что минимизирует количество обращений к базе данных. Это самый эффективный способ для известных зависимостей.

var orders = context.Orders
    .Include(o => o.OrderItems)
    .Include(o => o.Customer)
        .ThenInclude(c => c.Addresses)
    .Include(o => o.ShippingDetails)
    .ToList();

2. Пакетная загрузка с проекцией (Projection)

Для сложных сценариев с глубокой зависимостью можно использовать проекцию (Select) для загрузки только необходимых данных, избегая лишних полей и N+1 проблем.

var result = context.Orders
    .Select(o => new
    {
        Order = o,
        Items = o.OrderItems.ToList(),
        CustomerName = o.Customer.Name,
        ShippingInfo = o.ShippingDetails
    })
    .ToList();

3. Раздельная загрузка с последующим связыванием (Split Queries)

В EF Core 5+ появилась возможность разделения запросов (Split Queries), когда основной объект и зависимости загружаются отдельными запросами, что иногда улучшает производительность.

var orders = context.Orders
    .Include(o => o.OrderItems)
    .AsSplitQuery()
    .ToList();

Оптимизация для "очень многих" зависимых сущностей

Когда зависимые сущности исчисляются сотнями или тысячами, стандартные подходы могут стать неэффективными.

Проблема N+1 и ее решение

Классическая проблема N+1 запросов возникает при lazy loading или цикличной обработке. Решение — всегда использовать .Include() или проекцию.

Рекомендации для масштабирования

• Фильтрация на уровне базы: Добавляйте .Where() перед .Include() для ограничения зависимых данных.

var orders = context.Orders
    .Where(o => o.Date > DateTime.Now.AddDays(-30))
    .Include(o => o.OrderItems.Where(i => i.IsActive))
    .ToList();

• Ограничение глубины: Не загружайте сущности глубже 2-3 уровней без необходимости.
• Псевдо-lazy loading с явными запросами: Для очень глубоких или динамических зависимостей можно выполнять несколько явных запросов и手动 связывать данные в памяти.

var orders = context.Orders.ToList();
var orderIds = orders.Select(o => o.Id).ToList();
var items = context.OrderItems
    .Where(i => orderIds.Contains(i.OrderId))
    .ToList();

// Маппинг вручную или через Dictionary для связи
var itemsByOrder = items.GroupBy(i => i.OrderId).ToDictionary(g => g.Key, g => g.ToList());
foreach(var order in orders)
{
    order.OrderItems = itemsByOrder.GetValueOrDefault(order.Id, new List<OrderItem>());
}

• Репозиторий с кастомными SQL: Для экстремальных случаев используйте хранимые процедуры или сырой SQL через DbContext.Database.SqlQuery.

var orderData = context.Database.SqlQueryRaw<OrderAggregate>(
    "SELECT o.*, i.* FROM Orders o JOIN OrderItems i ON o.Id = i.OrderId WHERE ...");

Выбор стратегии

• Известные и ограниченные зависимости: .Include() с .ThenInclude().
• Глубокие или фильтрованные зависимости: Проекция или Split Queries.
• Очень большие объемы данных: Пакетная загрузка с маппингом или кастомный SQL.

Ключевое правило — загружать данные одним или несколькими оптимизированными запросами, избегая множественных отдельных обращений к базе. Используйте профилирование запросов (через DbContext.Log или SQL Server Profiler) для анализа реальной производительности.