В чем различия между жадной (Eager), ленивой (Lazy) и явной (Explicit) загрузкой данных в Entity Framework Core?

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

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

1. Жадная загрузка (Eager Loading) — «Всё и сразу»

Это когда ты, предвидя будущие запросы, грузишь всё нужное одним махом, одним здоровенным SQL-запросом с кучей JOIN. Делается через Include и ThenInclude.

// Всё загружается ОДНИМ запросом: блог, его посты, и авторы этих постов.
var blog = context.Blogs
    .Include(b => b.Posts)        // Тащим посты
        .ThenInclude(p => p.Author) // И заодно автора каждого поста
    .FirstOrDefault(b => b.Id == 1);

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

2. Ленивая загрузка (Lazy Loading) — «На, потрогай»

А это, сука, хитрая жопа. Данные подгружаются сами, прозрачно, в тот самый момент, когда ты впервые обращаешься к свойству. Но чтобы эта магия работала, нужно прыгнуть через хуй с винтом:

1. Поставить отдельный пакет Microsoft.EntityFrameworkCore.Proxies.
2. Включить это дело в конфигурации (UseLazyLoadingProxies()).
3. Все навигационные свойства сделать virtual.

public class Blog
{
    public int Id { get; set; }
    public virtual ICollection<Post> Posts { get; set; } // Виртуальное — ключевое слово!
}

// ... а в коде
var blog = context.Blogs.First(b => b.Id == 1); // Запрос 1: грузим только блог

// А вот тут начинается магия, ёпта
foreach (var post in blog.Posts) // Запрос 2: БАЦ! EF Core сам дергает базу за постами!
{
    Console.WriteLine(post.Title);
}

Чем хороша: Удобно, блядь. Не нужно заранее париться с Include. Загрузилось ровно то, до чего дотронулись. Чем плоха: О, это главная ловушка, пиздец! Проблема N+1. Представь: у тебя 100 блогов. Ты их загрузил (1 запрос). А потом в цикле к каждому обращаешься за постами. И EF Core, такой добрый, для каждого блога делает ОТДЕЛЬНЫЙ запрос за его постами. Итого: 1 + 100 = 101 запрос. База просто ляжет и захрипит, доверия к такому коду — ноль ебать.

3. Явная загрузка (Explicit Loading) — «Сам знаю, когда надо»

Здесь ты берёшь контроль в свои руки, как взрослый. Сначала грузишь основную сущность, а потом, когда сам решишь, что пора, явно говоришь контексту: «А теперь загрузи-ка мне вот это свойство».

var blog = context.Blogs.First(b => b.Id == 1); // Запрос 1: только блог

// Решили, что пора бы и посты подтянуть
context.Entry(blog)
    .Collection(b => b.Posts) // Указываем, что грузим коллекцию
    .Load(); // Запрос 2: SELECT * FROM Posts WHERE BlogId = 1

// Всё, теперь blog.Posts заполнена и готова к работе.

Чем хороша: Абсолютный контроль. Можно загружать данные по условию, когда угодно. Условно, «если пользователь премиум, то грузи все комментарии, а если нет — то не грузи нихуя». Чем плоха: Код становится более многословным, за каждым чихом нужно следить самому.

Так какую же выбрать, ёпта? Если вкратце: в 95% случаев бери жадную загрузку (Include). Она эффективная и понятная. Ленивую — только если ты на 100% уверен, что проблема N+1 тебе не грозит (что бывает редко), или для каких-то простых прототипов. А явную — когда логика загрузки действительно сложная и зависит от условий в рантайме.

Главное — не нарваться на N+1 с ленивой загрузкой, а то будет тебе хиросима, а не приложение.