Какие виды загрузки связанных данных вы знаете в Entity Framework Core?

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

1. Жадная загрузка (Eager Loading) — Всё и сразу Ты такой: «А дай-ка я за один присест вытащу блог, посты, авторов, комментарии, лайки и ещё хуй знает что». Делается через Include и ThenInclude. Получается один здоровенный SQL-запрос с кучей JOIN.

// Берём всё, что плохо лежит, одним махом
var blogs = await context.Blogs
    .Include(b => b.Posts)          // Цепляем посты
        .ThenInclude(p => p.Author) // К каждому посту — автора
    .Include(b => b.Posts)
        .ThenInclude(p => p.Comments) // А к каждому посту ещё и комменты
    .Include(b => b.Owner)           // И владельца блога, куда ж без него
    .ToListAsync();

Когда юзать: Когда точно знаешь, что тебе понадобится вся эта кухня. Например, рендеришь страницу блога, где всё сразу видно. Плюсы: Один запрос — и ты король. По идее, быстро. Минусы: А по факту можно так наджойнить, что сервер базы тебя возненавидит. Вытащишь мегабайты данных, а используешь три поля. Это как купить весь магазин, чтобы съесть булку.

2. Явная загрузка (Explicit Loading) — Ручное управление Ты сначала берёшь главную сущность, а потом, по мере надобности, подгружаешь к ней всё остальное. Как будто ходишь по магазину отдельно за хлебом, отдельно за колбасой.

// Нашли блог
var blog = await context.Blogs.FindAsync(1);

// А теперь, сука, подгрузи посты к нему
await context.Entry(blog)
    .Collection(b => b.Posts)
    .LoadAsync();

// И владельца не забудь
await context.Entry(blog)
    .Reference(b => b.Owner)
    .LoadAsync();

// А можно и с умом — только опубликованные и отсортированные
await context.Entry(blog)
    .Collection(b => b.Posts)
    .Query()
    .Where(p => p.IsPublished)
    .OrderBy(p => p.CreatedDate)
    .LoadAsync();

Когда юзать: Когда логика сложная. Например, комментарии грузим только если юзер ткнул «развернуть». Или если не знаешь заранее, что понадобится. Плюсы: Полный контроль. Загрузил именно то, что нужно, и именно когда нужно. Минусы: Если делать это в цикле для кучи блогов, получишь классический N+1 запрос. База сдохнет, а ты будешь чесать репу.

3. Ленивая загрузка (Lazy Loading) — Волшебный пендель Включил — и забыл. Обратился к свойству — оно само подгрузится. Красота? А вот нихуя.

Как включить эту магию:

1. Поставить пакет Microsoft.EntityFrameworkCore.Proxies.
2. В контексте написать:

   protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
   {
   optionsBuilder.UseLazyLoadingProxies(); // Включаем волшебство
   }

3. Все навигационные свойства сделать virtual (да, все, блядь).

   
   public class Blog
   {
   public int Id { get; set; }
   public virtual ICollection<Post> Posts { get; set; } // virtual — ключевое слово!
   }

// Используется просто var blog = context.Blogs.Find(1); var posts = blog.Posts; // В этот момент выстрелит отдельный SQL-запрос!

*Когда юзать:* Для быстрых прототипов, десктопных приложений или когда похуй на производительность.
*Плюсы:* Невероятно удобно. Пишешь код, не паришься о загрузке.
*Минусы:*
- **Тот самый N+1:** Цикл по 10 блогам? Получи 11 запросов к базе. Сервер базы данных тебя проклянёт.
- Запросы летят в неожиданных местах, отлаживать производительность — тот ещё ад.
- Надо плодить виртуальные свойства и прокси-классы.

**Альтернатива — Проекции (Select)**
Часто самый адекватный путь. Не грузишь сущности, а сразу выбираешь только нужные тебе данные, как на витрине.

```csharp
var result = await context.Blogs
    .Where(b => b.Id == 1)
    .Select(b => new BlogViewModel // Сразу в нужную форму
    {
        Name = b.Name,
        PostTitles = b.Posts.Select(p => p.Title).ToList() // JOIN будет, но только для нужных полей
    })
    .FirstOrDefaultAsync();

Вот это часто самое то. Контролируешь и запрос, и данные на выходе. EF Core сам оптимизирует JOIN. Меньше данных по сети, меньше работы для базы. Красота.

Итог:

• Жадная — когда знаешь всё наперёд.
• Явная — когда нужен контроль и условия.
• Ленивая — для прототипов или когда deadlines горят, а похуй.
• Проекции — часто лучший выбор для реальных сценариев. Учись ими пользоваться, а не долбить Include на 10 уровней вглубь.