# Вопросы для senior fullstack: backend на .NET

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

Метки **[Базовый]**, **[Средний]**, **[Сложный]** обозначают глубину вопроса. Для senior важны объяснение причин, корректность рассуждений и понимание компромиссов. Не требуется задавать весь банк за одну встречу: для этого есть отдельный [сценарий на 60 минут](hour.md).

Под ASP.NET и EF здесь понимаются **ASP.NET Core** и **Entity Framework Core**. Версионные особенности отмечены в соответствующих ответах. В разделе SQL есть одна небольшая задача с исходными данными, ожидаемым результатом и решением.

**Темы:**

1. [ООП, принципы разработки и проектирования](#basics)
2. [C#/.NET](#csharp)
3. [ASP.NET Core](#aspnet)
4. [SQL и небольшая задача](#sql)
5. [Entity Framework Core](#efcore)

<a id="basics"></a>

## 1. ООП, принципы разработки и проектирования

### Основы ООП

#### 1.1. [Базовый] Что такое ООП?

**Ответ:** Объектно-ориентированное программирование — парадигма, в которой программа строится вокруг взаимодействующих объектов. Объект объединяет состояние и поведение; его контракт определяет доступные клиенту операции. Основные принципы — абстракция, инкапсуляция, наследование и полиморфизм.

#### 1.2. [Базовый] Что такое абстракция?

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

#### 1.3. [Базовый] Что такое инкапсуляция?

**Ответ:** Инкапсуляция ограничивает доступ к внутреннему состоянию и реализации, задавая допустимые способы взаимодействия с объектом. Она помогает сохранять инварианты — условия корректности объекта. Публичные свойства с произвольными setter сами по себе этого не обеспечивают. [Основы ООП](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/oop).

#### 1.4. [Средний] Чем инкапсуляция отличается от абстракции?

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

#### 1.5. [Базовый] Что такое наследование?

**Ответ:** Наследование позволяет определить производный тип на основе базового, унаследовав его контракт и доступную реализацию. В C# класс может иметь один непосредственный базовый класс и реализовывать несколько интерфейсов. Наследование предполагает осмысленное отношение подтипа, а не только желание повторно использовать код.

#### 1.6. [Базовый] Что такое полиморфизм?

**Ответ:** Полиморфизм позволяет работать с разными реализациями через общий контракт. При вызове виртуального метода или реализации интерфейса фактический тип объекта определяет конкретное поведение. Клиенту не требуется перечислять все реализации и выбирать каждую через условие.

#### 1.7. [Средний] Чем абстрактный класс отличается от интерфейса?

**Ответ:** Абстрактный класс может хранить состояние экземпляра, иметь конструкторы и общую реализацию для семейства типов. Интерфейс задаёт контракт, доступный несвязанным типам; один тип может реализовать несколько интерфейсов. Современные интерфейсы допускают реализации членов по умолчанию, но не поля состояния экземпляра. [Интерфейсы C#](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/interfaces).

#### 1.8. [Средний] Когда нужен интерфейс для класса?

**Ответ:** Когда есть осмысленный контракт для клиентов, независимая граница компонентов или необходимость в альтернативном поведении. Автоматическое создание `IFoo` для каждого `Foo` не гарантирует хорошей архитектуры. Важны содержание контракта и независимость клиента от деталей реализации.

#### 1.9. [Базовый] Что такое перегрузка метода?

**Ответ:** Это несколько методов с одинаковым именем и разными сигнатурами. Для обычного статически типизированного вызова перегрузка выбирается при компиляции. Только различия возвращаемого типа недостаточно; вызовы с `dynamic` имеют отдельные правила разрешения во время выполнения.

#### 1.10. [Средний] Чем override отличается от new при объявлении метода?

**Ответ:** `override` переопределяет виртуальный член: при вызове через базовый тип выполняется подходящая реализация по фактическому типу объекта. `new` скрывает член, объявляя отдельный: выбор при обычном вызове зависит от статического типа выражения. Это разные механизмы, даже если имена методов совпадают. [Полиморфизм в C#](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/object-oriented/polymorphism).

#### 1.11. [Сложный] Почему опасен вызов виртуального метода из конструктора?

**Ответ:** Вызов может попасть в реализацию наследника до завершения его конструктора. Переопределённый метод получит частично настроенное состояние и может нарушить инварианты или завершиться ошибкой. Поэтому подобную зависимость от поведения наследника обычно исключают из конструирования.

#### 1.12. [Средний] Когда композиция удобнее наследования?

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

#### 1.13. [Средний] Что означают coupling и cohesion?

**Ответ:** Coupling — связанность компонентов: сколько знаний друг о друге им требуется и насколько распространяются изменения. Cohesion — связность внутри компонента: насколько его элементы служат одной задаче. Обычно стремятся к низкой внешней связанности и высокой внутренней связности; наличие интерфейса само по себе этого не обеспечивает. [Архитектурные принципы](https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles).

### SOLID и управление зависимостями

#### 1.14. [Базовый] Что такое SOLID?

**Ответ:** SOLID — пять принципов проектирования: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion. Они помогают разделять обязанности, сохранять корректность контрактов и управлять зависимостями при изменении программы. Это ориентиры проектирования, а не требование создавать максимальное число классов и интерфейсов.

#### 1.15. [Базовый] Что означает принцип единственной ответственности — SRP?

**Ответ:** Вместе следует размещать то, что меняется по одной причине, и разделять независимые причины изменений. У модуля должна быть одна связная ответственность. Принцип не требует, чтобы у класса был ровно один метод.

#### 1.16. [Средний] Что означает принцип открытости/закрытости — OCP?

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

#### 1.17. [Средний] Что означает принцип подстановки Лисков — LSP?

**Ответ:** Подтип должен сохранять обещания контракта, чтобы клиент мог использовать его вместо базового типа без нарушения ожидаемого поведения. В частности, нельзя усиливать предусловия или ослаблять постусловия. Это касается и реализаций интерфейса, а не только наследования классов.

#### 1.18. [Сложный] Всегда ли NotSupportedException означает нарушение LSP?

**Ответ:** Нет, всё зависит от контракта. Например, `Stream` допускает потоки без возможности позиционирования и предоставляет `CanSeek`. Нарушение появляется, когда реализация отказывается от поведения, которое контракт гарантировал. Совпадения сигнатур недостаточно: важна семантика. [Возможности Stream](https://learn.microsoft.com/en-us/dotnet/api/system.io.stream.canseek).

#### 1.19. [Средний] Что означает принцип разделения интерфейсов — ISP?

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

#### 1.20. [Средний] Что означает принцип инверсии зависимостей — DIP?

**Ответ:** Высокоуровневая логика и низкоуровневые компоненты должны зависеть от абстракций. Абстракции не зависят от деталей реализации; детали подчиняются абстракциям. Так бизнес-правила можно сохранить при замене инфраструктуры. [Пять принципов SOLID](https://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html).

#### 1.21. [Средний] Чем отличаются IoC и DI?

**Ответ:** Inversion of Control — более общая идея передачи управления внешнему механизму, например фреймворку. Dependency Injection — способ передавать объекту его зависимости извне, часто через конструктор. DI-контейнер автоматизирует создание графа объектов, но зависимости можно передать и вручную.

#### 1.22. [Средний] Чем DIP отличается от DI?

**Ответ:** DIP определяет направление зависимостей в проектировании. DI описывает способ предоставления зависимостей объекту. Внедрение конкретного инфраструктурного класса тоже является DI, но само по себе не обеспечивает соблюдения DIP. [Dependency injection](https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/overview).

#### 1.23. [Средний] Почему Service Locator может затруднять сопровождение?

**Ответ:** Когда бизнес-код получает всё через `IServiceProvider`, его зависимости становятся скрытыми и ошибки конфигурации обнаруживаются позднее. Конструктор делает зависимости явными и упрощает тестирование. Разрешение сервисов через контейнер уместно в инфраструктуре, например при создании scope фоновой операции.

### Простота, паттерны и тестирование

#### 1.24. [Базовый] Что означает DRY?

**Ответ:** Одно и то же знание или правило не должно независимо поддерживаться в нескольких местах. Похожий код не всегда представляет одно знание: если части меняются по разным причинам, их объединение может создать лишнюю связанность. Абстракцию выделяют, когда понятна общая ответственность.

#### 1.25. [Базовый] Что означает KISS?

**Ответ:** Следует выбирать понятное решение, которое удовлетворяет реальным требованиям без лишней сложности. Простота оценивается по лёгкости понимания и изменения, а не только по числу строк. Дополнительные уровни абстракции должны решать конкретную проблему.

#### 1.26. [Базовый] Что означает YAGNI?

**Ответ:** Не стоит реализовывать предполагаемые возможности до появления обоснованной потребности. Принцип не отменяет тесты, ясный дизайн и рефакторинг: они помогают изменять систему, когда необходимость возникнет. [YAGNI](https://martinfowler.com/bliki/Yagni.html).

#### 1.27. [Средний] Для чего нужен паттерн Strategy?

**Ответ:** Он выделяет взаимозаменяемые алгоритмы с общим контрактом. Клиент делегирует выбор или выполнение алгоритма стратегии, а разные варианты можно менять независимо. Типичный пример — несколько правил расчёта стоимости доставки.

#### 1.28. [Средний] Для чего нужен паттерн Decorator?

**Ответ:** Он оборачивает объект с сохранением контракта и добавляет поведение до или после делегированного вызова. Например, измерение времени или кэширование чтения. Нужно сохранять обещания исходного контракта и учитывать порядок нескольких обёрток.

#### 1.29. [Средний] Для чего нужна Factory?

**Ответ:** Фабрика инкапсулирует создание объекта, если оно зависит от параметров, выбора реализации или дополнительных правил. Она отделяет использование объекта от деталей конструирования. Для простого создания без вариативности отдельная фабрика может быть излишней.

#### 1.30. [Сложный] Когда повтор операции после ошибки безопасен?

**Ответ:** Нужно понимать, является ли ошибка временной и мог ли побочный эффект уже произойти. Для операций с побочными эффектами важны идемпотентность или механизм предотвращения дубликатов. Число попыток и общее время ограничивают; слепые повторы способны усилить перегрузку. [Условия применения retry](https://learn.microsoft.com/en-us/azure/architecture/patterns/retry).

#### 1.31. [Средний] Чем unit-тест отличается от интеграционного?

**Ответ:** Unit-тест проверяет небольшой законченный фрагмент поведения в изоляции от внешней инфраструктуры. Интеграционный проверяет взаимодействие компонентов, например выполнение запроса через реальный провайдер БД. Они обнаруживают разные классы ошибок и дополняют друг друга.

#### 1.32. [Средний] Что показывает процент покрытия тестами?

**Ответ:** Он показывает, какой код был выполнен во время тестов, но не доказывает корректность проверок. Важны значимые assertions, граничные случаи, повторяемость и понятные причины падения. Высокое покрытие возможно даже при слабой проверке результата. [Качество unit-тестов](https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-best-practices).

#### 1.33. [Средний] Когда полезно проверять вызовы mock-объекта?

**Ответ:** Когда взаимодействие само является частью проверяемого контракта, например отправка ровно одной команды. Проверка всех внутренних вызовов привязывает тест к реализации. Обычно предпочтительнее проверять наблюдаемое поведение, чтобы рефакторинг без изменения результата не ломал тесты.

<a id="csharp"></a>

## 2. C#/.NET

### Типы, Object и равенство

#### 2.1. [Базовый] Чем value types отличаются от reference types?

**Ответ:** Переменная значимого типа содержит значение, и присваивание копирует его. Переменная ссылочного типа содержит ссылку на объект, и присваивание копирует ссылку: несколько переменных могут указывать на один объект. К значимым относятся `struct` и `enum`, к ссылочным — классы, массивы, строки и делегаты.

#### 2.2. [Базовый] Что такое System.Object?

**Ответ:** `System.Object` — корневой базовый класс в иерархии классов .NET; `object` — его псевдоним в C#. Классы наследуют его прямо или косвенно. Значимые типы также связаны с ним через `System.ValueType`, но преобразование обычной структуры в `object` требует упаковки. [System.Object](https://learn.microsoft.com/en-us/dotnet/api/system.object?view=net-10.0).

#### 2.3. [Базовый] Какие методы есть у Object?

**Ответ:** Основные методы делятся на три группы:

- **Публичные методы экземпляра:** `Equals(object)` проверяет равенство, `GetHashCode()` возвращает хеш, `ToString()` — строковое представление, `GetType()` — фактический тип объекта. Первые три виртуальные; `GetType()` не виртуальный.
- **Публичные статические методы:** `Equals(object, object)` сравнивает значения с обработкой `null`, `ReferenceEquals(object, object)` проверяет идентичность ссылок.
- **Защищённые методы:** `MemberwiseClone()` создаёт поверхностную копию, `Finalize()` участвует в финализации. В C# финализатор объявляют синтаксисом `~TypeName()`, а не прямым переопределением или вызовом `Finalize`. Момент его выполнения не определён. [Методы Object](https://learn.microsoft.com/en-us/dotnet/api/system.object?view=net-10.0#methods), [финализация](https://learn.microsoft.com/en-us/dotnet/api/system.object.finalize?view=net-10.0).

#### 2.4. [Базовый] Для чего нужен Equals?

**Ответ:** `Equals` определяет, считаются ли два объекта или значения равными по правилам типа. Базовая реализация для класса проверяет идентичность объектов; реализация `ValueType` для структур сравнивает поля. Тип может переопределить равенство, например сравнивать два адреса по их составляющим, хотя это разные экземпляры.

#### 2.5. [Базовый] Для чего нужен ReferenceEquals?

**Ответ:** `ReferenceEquals` проверяет, указывают ли две ссылки на один объект, либо обе равны `null`. Он не использует переопределённый `Equals` и перегруженный `==`. Поэтому два отдельных объекта могут быть равны по содержимому, но дать `false` при проверке идентичности.

#### 2.6. [Средний] Чем оператор == отличается от Equals?

**Ответ:** `==` — оператор, который может быть перегружен; при обычном статически типизированном вызове его выбор зависит от типов выражений. Вызов виртуального `Equals` учитывает реализацию фактического типа объекта. Например, две строки в переменных типа `object` сравниваются через `==` по ссылкам, а через `Equals` — по содержимому. У произвольной структуры `==` автоматически не появляется.

#### 2.7. [Средний] Зачем реализовывать IEquatable<T>?

**Ответ:** Интерфейс предоставляет типизированный `Equals(T)`, используемый стандартными generic-компараторами. Для структур это помогает избежать упаковки при сравнении. Его поведение нужно согласовать с `Equals(object)`, `GetHashCode` и перегруженными операторами; равенство должно быть рефлексивным, симметричным и транзитивным. [Равенство в C#](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/expressions/equality).

#### 2.8. [Базовый] Для чего нужен GetHashCode?

**Ответ:** Он вычисляет хеш, с помощью которого хеш-коллекции быстро сужают круг кандидатов для сравнения. Хеш не заменяет проверку равенства и не является уникальным идентификатором. Его нельзя сохранять как стабильный отпечаток между запусками: результат может зависеть от процесса и реализации .NET.

#### 2.9. [Средний] Как связаны Equals и GetHashCode?

**Ответ:** Если два значения равны согласно используемому сравнению, их хеш-коды обязаны совпадать. Обратное неверно: у разных значений могут быть одинаковые хеши. При переопределении `Equals` нужно согласованно переопределить `GetHashCode`, обычно по тем же значимым полям; для объединения хешей подходит `HashCode.Combine`. [Контракт GetHashCode](https://learn.microsoft.com/en-us/dotnet/api/system.object.gethashcode).

#### 2.10. [Средний] Допустим ли GetHashCode, который всегда возвращает одно число?

**Ответ:** Формально контракт соблюдается: равные значения имеют одинаковый хеш. Но все ключи попадают в коллизии, и поиск в хеш-коллекции может превратиться в последовательный перебор. Это пример логически допустимой, но практически неэффективной реализации.

### Dictionary и использование равенства

#### 2.11. [Средний] Как Dictionary находит значение по ключу?

**Ответ:** По хешу ключа выбирается корзина, а среди её кандидатов ищется ключ, равный по используемому comparer. Коллизия не приводит к произвольной перезаписи: разные ключи различаются сравнением. Когда ёмкости недостаточно, внутреннее хранилище расширяется, а записи перераспределяются.

#### 2.12. [Средний] Какова сложность операций Dictionary?

**Ответ:** Поиск в среднем близок к `O(1)`, добавление — к амортизированному `O(1)`, поскольку иногда требуется расширение. При большом числе коллизий отдельная операция может занять `O(n)`. Дополнительно учитывается стоимость вычисления хеша и сравнения ключей.

#### 2.13. [Средний] Почему нельзя менять ключ после добавления в Dictionary?

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

#### 2.14. [Средний] Как задать собственные правила сравнения ключей?

**Ответ:** Передать `IEqualityComparer<TKey>` при создании словаря; без него используется `EqualityComparer<TKey>.Default`. Например, `StringComparer.OrdinalIgnoreCase` задаёт сравнение строковых ключей без учёта регистра. Компаратор должен согласованно определять и равенство, и хеш.

#### 2.15. [Базовый] Когда использовать TryGetValue?

**Ответ:** Когда ключ может отсутствовать: метод возвращает признак успеха и значение через `out`. Это позволяет обойтись одним поиском вместо `ContainsKey` с последующим индексатором и не использовать исключение для обычного отсутствия ключа.

#### 2.16. [Средний] Потокобезопасен ли обычный Dictionary?

**Ответ:** Несколько читателей допустимы, пока словарь не изменяется. При конкурентных изменениях нужна внешняя синхронизация либо подходящая конкурентная коллекция. Даже безопасная коллекция не делает автоматически атомарной произвольную последовательность операций над ней. [Dictionary](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2).

### Копирование, размещение и передача параметров

#### 2.17. [Базовый] Значимые типы всегда находятся в стеке?

**Ответ:** Нет. Структура может быть полем объекта или элементом массива в управляемой куче; локальное значение может находиться в регистре. Ссылка тоже может храниться в поле объекта в куче. Категория типа определяет прежде всего семантику значения, а размещение зависит от контекста и оптимизаций. [Типы C#](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/types).

#### 2.18. [Базовый] Чем поверхностное копирование отличается от глубокого?

**Ответ:** При поверхностном копировании копируются значения полей, в том числе ссылки. Поэтому две копии структуры с полем `List<int>` указывают на один список; аналогично работает `MemberwiseClone` для полей объекта. Глубокое копирование отдельно копирует нужные вложенные объекты, по правилам конкретной модели данных. [MemberwiseClone](https://learn.microsoft.com/en-us/dotnet/api/system.object.memberwiseclone?view=net-10.0).

#### 2.19. [Базовый] Как параметры передаются по умолчанию?

**Ответ:** По значению. Для ссылочного типа копируется ссылка: метод может изменить доступное состояние объекта, но присваивание параметру нового объекта не заменит переменную вызывающего кода. Для структуры копируется сама структура, вместе со значениями её полей.

#### 2.20. [Базовый] Для чего нужен ref-параметр?

**Ответ:** Он предоставляет доступ к переменной вызывающего кода, позволяя читать и заменять её значение. Переменная должна быть инициализирована до вызова. Для ссылочного типа это позволяет изменить не только объект, но и ссылку, хранящуюся у вызывающего кода.

#### 2.21. [Базовый] Для чего нужен out-параметр?

**Ответ:** Он позволяет вернуть значение через параметр без требования предварительной инициализации переменной. При нормальном возврате метод обязан присвоить ему значение. Такой контракт используется, например, в `TryParse` и `TryGetValue`.

#### 2.22. [Средний] Для чего нужен in-параметр?

**Ответ:** Он предоставляет доступ по ссылке только для чтения и может уменьшить копирование больших структур. Запрещается изменение самого параметра, но для ссылочного типа доступное состояние объекта остаётся изменяемым. Передача через `in` не является гарантией ускорения. [Параметры методов](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters).

#### 2.23. [Сложный] Почему in иногда приводит к защитной копии структуры?

**Ответ:** Если через readonly-ссылку вызвать метод изменяемой структуры, не объявленный `readonly`, компилятору может потребоваться копия, чтобы защитить исходное значение от изменения. Это снижает ожидаемую выгоду `in`. Помогают осмысленный выбор `readonly struct` и измерение производительности.

### Class, struct, record и обобщённые типы

#### 2.24. [Средний] Когда выбирать class, а когда struct?

**Ответ:** Класс удобен для сущности с идентичностью, общим изменяемым состоянием или наследованием. Структура подходит для относительно небольшого самостоятельного значения, когда копирование соответствует смыслу данных. Большие изменяемые структуры могут давать дорогие и неожиданные копии; выбор полезно проверять на реальном использовании.

#### 2.25. [Средний] Что гарантирует readonly struct?

**Ответ:** Она запрещает изменение собственного состояния после создания и обозначает соответствующий контракт для её членов. Но неизменяемость поверхностная: список, на который указывает поле структуры, всё ещё можно изменить через другую ссылку или доступный API.

#### 2.26. [Средний] Чем record отличается от обычного class или struct?

**Ответ:** `record` добавляет сгенерированное равенство по данным и удобные операции, например копирование с изменениями через `with`. `record` и `record class` — ссылочные типы, `record struct` — значимый. При этом свойства вложенных типов влияют на результат сравнения и копирования.

#### 2.27. [Средний] Делает ли record объект неизменяемым?

**Ответ:** Нет: record может иметь изменяемые свойства. `init` ограничивает присваивание свойства при инициализации, но не запрещает менять вложенный список. `with` по умолчанию создаёт поверхностную копию, поэтому ссылочные поля могут остаться общими. [Records](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record).

#### 2.28. [Средний] Равны ли два record с разными массивами одинакового содержимого?

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

#### 2.29. [Базовый] Что такое boxing?

**Ответ:** Boxing — преобразование значения в объектное представление, например при присваивании `int` переменной `object`. Обычно создаётся объект с копией значения; последующее изменение исходной структуры не меняет эту копию. Упаковка добавляет расходы на выделение памяти и последующую работу GC.

#### 2.30. [Средний] Что такое unboxing?

**Ответ:** Это извлечение значимого типа из его упакованного представления. Тип должен соответствовать упакованному: если в `object` находится `int`, `(long)boxed` завершится `InvalidCastException`. Сначала нужно получить `int`, затем выполнить обычное числовое преобразование: `(long)(int)boxed`. [Boxing и unboxing](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/boxing-and-unboxing).

#### 2.31. [Базовый] Зачем нужны generics?

**Ответ:** Обобщённые типы и методы позволяют повторно использовать алгоритмы с сохранением информации о типах и проверок компилятора. Например, `List<int>` хранит значения `int` без упаковки каждого элемента, необходимой для `List<object>`. Ограничения `where T : ...` задают требования к аргументу типа и доступные операции.

#### 2.32. [Сложный] Всегда ли вызов интерфейсного метода структуры требует boxing?

**Ответ:** Нет. Вызов через generic-параметр с подходящим ограничением может выполняться без упаковки. Но преобразование структуры в переменную интерфейсного типа обычно создаёт упакованное представление. Поэтому важны форма вызова и статические типы в конкретном участке кода.

### Строки и nullable-типы

#### 2.33. [Базовый] Что означает неизменяемость string?

**Ответ:** API `string` не предоставляет изменения символов существующего экземпляра. Операции вроде замены символов возвращают результат, а переменная может получить другую строку. Благодаря этому общая ссылка на строку не создаёт проблем совместного изменения её содержимого. При этом `string` остаётся ссылочным типом.

#### 2.34. [Средний] Что такое интернирование строк?

**Ответ:** Это переиспользование одного экземпляра для некоторых строк с одинаковым содержимым. Оно может сделать ссылки равными, но сравнение строковых значений нельзя основывать на этом. Для проверки содержимого используют предусмотренные строкой операции сравнения с подходящими правилами.

#### 2.35. [Базовый] Когда нужен StringBuilder?

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

#### 2.36. [Средний] Как правильно сравнивать строки без учёта регистра?

**Ответ:** Нужно явно выбрать правила: для технических идентификаторов обычно подходит `OrdinalIgnoreCase`, для лингвистического сравнения — нужная культура. Преобразование обоих значений через `ToLower()` создаёт лишние строки и может неожиданно зависеть от культуры. Для словарей те же правила задают через `StringComparer`. [Сравнение строк](https://learn.microsoft.com/en-us/dotnet/standard/base-types/best-practices-strings).

#### 2.37. [Базовый] Что означает тип `int?`?

**Ответ:** Запись `int?` означает `Nullable<int>` — значимый тип, который представляет число либо отсутствие значения. `HasValue` показывает наличие числа; обращение к `Value`, когда его нет, бросает `InvalidOperationException`. Это отдельный тип, а не только подсказка компилятору.

#### 2.38. [Базовый] Что означает аннотация `string?`?

**Ответ:** Запись `string?` — аннотация nullable reference types для анализа компилятором. Во время выполнения `string` и `string?` обозначают один тип `System.String`. Аннотации сами по себе не добавляют проверок: `null` может попасть даже в переменную `string`, например из legacy-кода. [Nullable reference types](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/nullable-reference-types).

#### 2.39. [Базовый] Защищает ли оператор ! от NullReferenceException?

**Ответ:** Нет. Null-forgiving operator подавляет соответствующее предупреждение компилятора, но не проверяет и не меняет значение. Если выражение равно `null`, его последующее разыменование всё равно может завершиться исключением.

#### 2.40. [Базовый] Для чего нужны операторы `?.` и `??`?

**Ответ:** `?.` выполняет доступ к члену, только если получатель не равен `null`; иначе результат такого доступа — `null`. `??` выбирает правый операнд, если левый равен `null`. Они позволяют явно описать поведение при отсутствии значения, но не заменяют необходимую валидацию входных данных.

### Управляемая память и освобождение ресурсов

#### 2.41. [Базовый] Как работает сборщик мусора — GC?

**Ответ:** GC определяет, какие объекты достижимы из корней: например, статических полей, живых локальных ссылок и специальных runtime-handles. Память недостижимых объектов может быть освобождена. Циклические ссылки между объектами сами по себе не мешают сборке, если весь цикл недостижим извне.

#### 2.42. [Средний] Для чего у GC несколько поколений?

**Ответ:** Большинство небольших новых объектов попадает в поколение 0; пережившие сборки объекты продвигаются в поколения 1 и 2. Это позволяет чаще проверять молодые объекты, многие из которых быстро становятся ненужными. Сборка старшего поколения включает младшие.

#### 2.43. [Средний] Что такое LOH?

**Ответ:** Large Object Heap — область для крупных объектов. По умолчанию порог составляет примерно 85 000 байт; её сборка связана с поколением 2. Частые крупные аллокации могут создавать заметную нагрузку. Порог и устройство — детали runtime, а не правило языка C#. [Основы GC](https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals).

#### 2.44. [Средний] Почему в .NET возможны утечки памяти?

**Ответ:** Ненужные приложению объекты могут оставаться достижимыми через кеш, статическую коллекцию или подписку на событие. GC не знает, что бизнес-логике они больше не нужны. При диагностике сравнивают темп аллокаций и удерживаемую память, изучают heap dump и пути к корням. `GC.Collect()` не устраняет удерживающую ссылку.

#### 2.45. [Базовый] Зачем нужен IDisposable, если есть GC?

**Ответ:** GC управляет памятью, а `Dispose` позволяет своевременно освобождать ресурсы: файлы, соединения, системные дескрипторы и регистрации. Доступность объекта для сборки не означает немедленного освобождения этих ресурсов. Наличие `IDisposable` также не делает объект потокобезопасным.

#### 2.46. [Базовый] Как работает using?

**Ответ:** `using` обеспечивает вызов `Dispose` при выходе из области, в том числе при обычном раскручивании стека из-за исключения. У блока `using (...) { ... }` граница задаётся блоком; у `using var` — концом текущей области видимости. Это механизм управления ресурсом, а не принудительный запуск GC.

#### 2.47. [Средний] Для чего нужны IAsyncDisposable и await using?

**Ответ:** `IAsyncDisposable` предоставляет `DisposeAsync` для освобождения ресурса, которое включает асинхронную работу. `await using` дожидается этого освобождения при выходе из области. Его выбирают, когда контракт ресурса требует или поддерживает соответствующее асинхронное завершение.

#### 2.48. [Средний] Чем финализатор отличается от Dispose?

**Ответ:** Финализатор — недетерминированная страховка для непосредственно удерживаемого unmanaged-ресурса; время его вызова нельзя использовать как бизнес-гарантию. `Dispose` вызывается явно владельцем или через `using`. Обычно unmanaged-ресурс удобнее обернуть в `SafeHandle`; владение только другими managed disposable-объектами не требует собственного финализатора. [Реализация Dispose](https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/implementing-dispose).

#### 2.49. [Средний] Нужно ли самостоятельно освобождать объект, полученный из DI?

**Ответ:** Освобождением обычно управляет владеющий объектом контейнер или scope. Решение зависит от контракта владения: чужой ресурс нельзя закрывать только из-за наличия `IDisposable`. Отдельно созданным экземпляром, например полученным через фабрику с передачей владения вызывающему коду, нужно управлять согласно контракту этой фабрики.

### Делегаты, события и замыкания

#### 2.50. [Базовый] Что такое делегат?

**Ответ:** Делегат — типизированный вызываемый объект, который хранит метод или список обработчиков с совместимой сигнатурой. Он позволяет передавать поведение как значение. `Action<...>` представляет вызов без результата, `Func<...>` — с возвращаемым результатом.

#### 2.51. [Средний] Чем событие отличается от публичного поля-делегата?

**Ответ:** `event` ограничивает внешнему коду доступ к подписке и отписке. Клиент не может произвольно заменить весь список обработчиков или вызвать событие. При обычной подписке долгоживущий издатель удерживает делегат, а тот может удерживать подписчика, поэтому жизненным циклом подписки нужно управлять.

#### 2.52. [Средний] Что захватывает замыкание?

**Ответ:** Замыкание сохраняет доступ к переменным внешней области, а не обязательно их значения на момент создания лямбды. Если переменная изменится, поздний вызов увидит новое значение. Захваченные объекты могут жить дольше, чем ожидается, пока сохраняются ссылки на замыкание.

```csharp
int number = 1;
Func<int> read = () => number;
number = 2;
Console.WriteLine(read()); // 2
```

#### 2.53. [Средний] Что ограничивает static-лямбда?

**Ответ:** Она запрещает захватывать внешние локальные переменные и состояние экземпляра через `this`. Это помогает делать зависимости явными и предотвращать случайное удержание объектов замыканием. Доступ к статическим членам при этом остаётся возможен. [Лямбды и захват](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions).

### LINQ и итераторы

#### 2.54. [Базовый] Что представляет IEnumerable<T>?

**Ответ:** Это контракт последовательного перечисления элементов. Он не гарантирует, что элементы уже находятся в памяти: они могут вычисляться или читаться по мере обхода. Операторы LINQ to Objects работают с такой последовательностью и переданными делегатами.

#### 2.55. [Средний] Чем IQueryable<T> отличается от IEnumerable<T>?

**Ответ:** `IQueryable<T>` дополнительно представляет запрос деревом выражений и связывает его с провайдером. Провайдер может перевести выражение, например, в SQL. Поэтому значение имеет, какие операции поддерживает провайдер и где именно произойдёт переход к обработке в приложении.

#### 2.56. [Базовый] Когда выполняется LINQ-запрос?

**Ответ:** Многие операторы, например `Where` и `Select`, откладывают работу до перечисления. `ToList` и `ToArray` материализуют результат; скалярные операции вроде `Count` или `First` вычисляют его при вызове. Повторное перечисление исходного запроса может повторить вычисления, побочные эффекты или обращение к БД.

#### 2.57. [Средний] Что делает AsEnumerable()?

**Ответ:** Он не загружает весь результат немедленно, но переводит последующие LINQ-вызовы к операциям над `IEnumerable`. Если источник — запрос к БД, следующий фильтр может выполняться уже в приложении. Это способно увеличить объём переданных строк. [Выполнение LINQ-запросов](https://learn.microsoft.com/en-us/dotnet/csharp/linq/get-started/introduction-to-linq-queries).

#### 2.58. [Средний] Когда материализация через ToList() полезна?

**Ответ:** Когда нужен сохранённый результат для повторного обхода или дальнейшей работы после завершения чтения источника. Цена — память и полное получение результата. Фильтрацию и ограничение объёма по возможности применяют до материализации; добавление `ToList` в произвольное место не является универсальной оптимизацией.

#### 2.59. [Средний] Означает ли отложенное выполнение отсутствие буферизации?

**Ответ:** Нет. Например, сортировка LINQ to Objects начинается при перечислении, но перед выдачей первого отсортированного элемента должна прочитать исходную последовательность. Отложенность описывает момент начала работы, а потоковая обработка — способ получения результата.

#### 2.60. [Средний] Как работает yield return?

**Ответ:** Компилятор превращает итератор в автомат состояний. При перечислении `yield return` выдаёт элемент и сохраняет состояние, следующее продвижение продолжает работу. `yield break` завершает последовательность. Тело итератора и его исключения обычно проявляются при перечислении; для немедленной проверки аргументов используют внешний обычный метод.

#### 2.61. [Средний] Когда освобождаются ресурсы итератора?

**Ответ:** Ресурс, открытый внутри итератора через `using`, остаётся открытым между выдачей элементов. Он освобождается при завершении или корректном освобождении перечислителя. `foreach` освобождает подходящий перечислитель и при `break`; при ручном обходе за это отвечает вызывающий код. [Итераторы](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/yield).

### Исключения

#### 2.62. [Базовый] Где следует перехватывать исключение?

**Ответ:** Там, где можно восстановиться, преобразовать ошибку в понятный контракт или добавить необходимый контекст. Бесшумное подавление исключения скрывает проблему и может оставить состояние некорректным. Для частых ожидаемых ситуаций подходят `TryParse`, `TryGetValue` или явный результат операции.

#### 2.63. [Средний] Чем throw отличается от throw ex внутри catch?

**Ответ:** `throw;` сохраняет исходную информацию о стеке, а `throw ex;` начинает её заново с точки повторного выбрасывания. При создании нового исключения исходное можно сохранить в `InnerException`. Для отложенного перебрасывания вне текущего `catch` существует `ExceptionDispatchInfo`.

#### 2.64. [Средний] Для чего нужны фильтры исключений?

**Ответ:** `catch (...) when (...)` перехватывает исключение только при выполнении условия. Так можно обрабатывать лишь известные случаи, пропуская остальные выше. Освобождение ресурсов всё равно организуют отдельно через `using` или `finally`. [Обработка исключений](https://learn.microsoft.com/en-us/dotnet/standard/exceptions/best-practices-for-exceptions).

### Асинхронность: от async/await к управлению операциями

#### 2.65. [Базовый] Что такое асинхронность и как она работает?

**Ответ:** Асинхронность позволяет начать операцию и продолжить другую работу, пока результат ещё не готов. Например, при асинхронном сетевом запросе .NET возвращает `Task`. Если запрос ещё выполняется, `await` приостанавливает метод и возвращает управление вызывающему коду, освобождая поток на время ожидания. Когда операция завершается, выполнение метода может продолжиться с результатом или исключением. Асинхронность сама по себе не требует параллельных вычислений или отдельного потока для каждого запроса. [Асинхронное программирование в C#](https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/async-scenarios).

#### 2.66. [Базовый] Как работает async/await?

**Ответ:** Компилятор преобразует async-метод в машину состояний, сохраняющую данные между продолжениями. Метод выполняется синхронно до первого ожидания незавершённой операции; затем возвращает управление вызывающему коду. `await` не блокирует поток на время ожидания. Само слово `async` не создаёт поток, поэтому тяжёлый цикл до первого ожидания может блокировать UI. [Механизм async](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async).

#### 2.67. [Базовый] Что представляет собой Task?

**Ответ:** `Task` представляет завершение операции, её ошибку или отмену; `Task<T>` также предоставляет результат типа `T`. У задачи не обязательно есть выделенный поток: например, ожидание сетевого ответа может обходиться без занятого ожидающего потока. Готовую задачу можно ожидать без асинхронной приостановки.

#### 2.68. [Базовый] Чем Thread отличается от ThreadPool?

**Ответ:** `Thread` представляет поток исполнения. `ThreadPool` управляет набором переиспользуемых потоков, которым выдаются работы и продолжения. Создавать отдельный поток на каждый небольшой запрос обычно дорого; пул уменьшает эти накладные расходы, но его потоки также можно занять блокирующими ожиданиями.

#### 2.69. [Средний] Когда нужен Task.Run?

**Ответ:** `Task.Run` отправляет работу в пул потоков. Он полезен, например, для выноса CPU-вычислений из UI-потока. Для I/O предпочтительны асинхронный API и `await`; обёртка уже асинхронного HTTP-вызова в `Task.Run` обычно избыточна. На сервере перенос вычисления между потоками пула сам по себе не увеличивает доступную мощность CPU. [I/O и CPU](https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/async-scenarios).

#### 2.70. [Средний] Достаточно ли Task.Run для надёжной фоновой обработки?

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

#### 2.71. [Средний] Для чего нужен Task.WhenAll?

**Ответ:** Он создаёт задачу, завершающуюся после всех переданных задач. Если сначала вызвать несколько асинхронных операций, они могут выполняться конкурентно; последовательные `await LoadA(); await LoadB();` запускают вторую только после первой. Сам `WhenAll` не запускает операции, не выделяет каждой поток и не ограничивает их количество.

#### 2.72. [Сложный] Как Task.WhenAll обрабатывает ошибки?

**Ответ:** Он дожидается всех задач; ошибка одной не отменяет остальные автоматически. При наличии ошибок объединённая задача становится faulted, а `await` распространяет одно исключение. Полный набор доступен через `Exception.InnerExceptions` объединённой задачи. Если ошибок нет, но хотя бы одна задача отменена, отменяется и объединённая. [Контракт WhenAll](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.whenall).

#### 2.73. [Средний] Как ограничить число одновременно выполняемых операций?

**Ответ:** Используют семафор, ограниченное число работников, канал с ограниченной ёмкостью или `Parallel.ForEachAsync` с заданным пределом параллелизма. Ограничение выбирают с учётом CPU и возможностей внешних систем. Семафор внутри миллиона заранее созданных задач ограничит активные операции, но не устранит расход памяти на сами задачи.

### Контекст выполнения и блокирующие ожидания

#### 2.74. [Средний] Что определяет место выполнения продолжения после await?

**Ответ:** При ожидании `Task` обычно учитывается текущий `SynchronizationContext`, а при его отсутствии — нестандартный `TaskScheduler`. UI-контекст позволяет вернуться на UI-поток. У ASP.NET Core собственного контекста синхронизации запроса по умолчанию нет. Если задача уже завершена, выполнение может продолжиться сразу без переключения потока.

#### 2.75. [Сложный] Для чего нужен ConfigureAwait(false)?

**Ответ:** Он сообщает, что для этого ожидания возвращение в захваченный контекст синхронизации или планировщик не требуется. Это полезно в библиотечном коде, которому не нужен контекст вызывающего приложения. Он не гарантирует переключения потока и не делает синхронно блокирующий код асинхронным. [ConfigureAwait FAQ](https://devblogs.microsoft.com/dotnet/configureawait-faq/).

#### 2.76. [Сложный] Влияет ли ConfigureAwait(false) на AsyncLocal<T>?

**Ответ:** Сам по себе не отключает передачу значений `AsyncLocal<T>`. Они распространяются через `ExecutionContext`, который отличается от `SynchronizationContext`. Поэтому отказ от возвращения в UI-контекст не означает потерю логического контекста асинхронной операции.

#### 2.77. [Средний] Чем опасно синхронное ожидание задачи?

**Ответ:** `.Result`, `.Wait()` и `.GetAwaiter().GetResult()` могут блокировать поток. В UI возможен deadlock, если продолжение ожидаемой операции требует того же занятого UI-контекста. В ASP.NET Core массовые блокировки могут истощить пул потоков. `.GetAwaiter().GetResult()` передаёт исходное исключение вместо `AggregateException`, характерного для `.Result`/`.Wait()`, но не устраняет блокировку.

#### 2.78. [Сложный] Что такое ThreadPool starvation?

**Ответ:** Это ситуация, когда работе не хватает доступных потоков пула, например из-за множества блокирующих ожиданий. Растут очереди и задержки, хотя CPU может быть загружен не полностью. Проверяют метрики пула и стеки потоков. Увеличение минимального числа потоков иногда смягчает симптомы; основную причину устраняют, убирая ненужные блокировки. [Диагностика starvation](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/debug-threadpool-starvation).

#### 2.79. [Средний] Почему следует избегать async void?

**Ответ:** Его нельзя ожидать, а `try/catch` вокруг вызова не обеспечивает обработку ошибок тела. Исключения направляются в контекст синхронизации или механизм необработанных исключений и могут завершить процесс. Основное применение — обработчики событий с сигнатурой `void`. У `List<T>.ForEach(async x => ...)` тоже получается `async void`: для ожидаемой последовательной обработки нужен `foreach` с `await`. [Возвращаемые типы async](https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/async-return-types).

### Отмена, асинхронные результаты и время жизни

#### 2.80. [Средний] Как работает CancellationToken?

**Ответ:** Отмена кооперативна: `CancellationTokenSource` сообщает о запросе отмены, а операция проверяет токен или передаёт его поддерживающему API. `Cancel()` не прерывает произвольный поток и не откатывает совершённые действия. Для объединения отмены клиента и лимита времени используют связанный источник с `CancelAfter`; источник освобождают после работы. [Модель отмены](https://learn.microsoft.com/en-us/dotnet/standard/threading/cancellation-in-managed-threads).

#### 2.81. [Средний] Отменяет ли Task.WaitAsync(timeout) исходную операцию?

**Ответ:** Нет: он ограничивает время ожидания, а исходная операция может продолжаться. Чтобы запросить её остановку, нужно передать ей токен отмены. Даже после запроса отмены операция должна самостоятельно завершиться и освободить ресурсы; поддержка отмены зависит от вызываемого API. [Контракт WaitAsync](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.waitasync).

#### 2.82. [Сложный] Когда полезен ValueTask<T>?

**Ответ:** Он может хранить готовый результат либо представлять операцию через `Task<T>` или `IValueTaskSource<T>`. Это позволяет уменьшить аллокации в часто вызываемом API, особенно при частом синхронном завершении. Структура крупнее ссылки и сложнее в использовании, поэтому исходный выбор обычно `Task<T>`, а пользу `ValueTask<T>` подтверждают измерениями. [Устройство ValueTask](https://devblogs.microsoft.com/dotnet/understanding-the-whys-whats-and-whens-of-valuetask/).

#### 2.83. [Сложный] Какие ограничения есть у потребления ValueTask?

**Ответ:** Общее правило — ожидать экземпляр один раз и не использовать его конкурентно: внутри может быть переиспользуемый источник. Для нескольких ожиданий или передачи в `WhenAll` можно один раз вызвать `AsTask()` и дальше использовать полученный `Task`. Исходный `ValueTask` после этого отдельно не потребляют; преобразование может снизить выгоду оптимизации.

#### 2.84. [Средний] Чем IAsyncEnumerable<T> отличается от Task<List<T>>?

**Ответ:** `Task<List<T>>` предоставляет готовый список после завершения операции. `IAsyncEnumerable<T>` позволяет постепенно получать элементы через `await foreach`, асинхронно ожидая следующий. Это может уменьшить задержку до первого элемента и объём памяти, но источник всё ещё способен буферизовать данные. При выходе из `await foreach` перечислитель освобождается через `DisposeAsync`, включая выход по `break` или исключению.

#### 2.85. [Средний] Как передать отмену асинхронному итератору?

**Ответ:** Потребитель может использовать `WithCancellation(token)`. Метод-итератор принимает токен с `[EnumeratorCancellation]` и передаёт его реальным операциям. Передача токена сама по себе не прерывает код, который его не проверяет и не поддерживает отмену. [Асинхронные потоки](https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/generate-consume-asynchronous-stream).

#### 2.86. [Средний] Можно ли перечислять данные после освобождения DbContext?

**Ответ:** Нельзя, если перечисление ещё обращается к БД. Контекст и необходимые ресурсы должны оставаться доступны до фактического завершения чтения; медленный потребитель может удерживать их долго. Уже материализованный результат можно читать после закрытия контекста, если последующий доступ не требует новой загрузки.

#### 2.87. [Сложный] Когда нельзя заменить return await на возврат Task?

**Ответ:** Когда метод должен удерживать ресурс до завершения операции. При `using var reader = ...; return reader.ReadToEndAsync();` ресурс закрывается при возврате задачи, хотя чтение может продолжаться. Ожидание внутри области `using` сохраняет правильное время жизни:

```csharp
static async Task<string> ReadTextAsync(string path)
{
    using var reader = new StreamReader(path);
    return await reader.ReadToEndAsync();
}
```

Прямой возврат задачи уместен для простого перенаправления вызова без подобных требований. [Область действия using](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/using).

#### 2.88. [Средний] Поймает ли try/catch ошибку задачи без await?

**Ответ:** `try { return OperationAsync(); } catch { ... }` ловит только исключение, выброшенное синхронно при получении задачи. Ошибка её последующего завершения в этот `catch` не попадёт. Чтобы обработать её здесь, нужно ожидать задачу внутри `try`, например через `return await OperationAsync()`.

### Потокобезопасность и синхронизация

#### 2.89. [Базовый] Почему counter++ небезопасен при конкурентном доступе?

**Ответ:** Увеличение состоит из чтения, вычисления и записи. Два потока могут прочитать одно исходное значение и записать одинаковый результат, потеряв одно увеличение. Атомарность отдельных чтений и записей `int` не делает атомарной всю последовательность. Для независимого счётчика подходит `Interlocked.Increment(ref counter)`.

#### 2.90. [Средний] Для чего нужен Interlocked?

**Ответ:** Он предоставляет атомарные операции над отдельным значением, например `Increment`, `Exchange` и условную замену `CompareExchange`. Но несколько вызовов не образуют одну общую атомарную операцию. Для согласованного изменения нескольких связанных полей нужен общий протокол защиты, обычно `lock`; все читатели также должны его соблюдать. [Операции Interlocked](https://learn.microsoft.com/en-us/dotnet/api/system.threading.interlocked).

#### 2.91. [Средний] Что гарантирует lock?

**Ответ:** Он обеспечивает взаимное исключение для синхронного участка; при конкуренции поток может блокироваться. Для обычного объекта применяется `Monitor`, для `System.Threading.Lock` в C# 13+ предусмотрена специальная поддержка компилятора. Используют отдельный приватный объект блокировки, чтобы внешнему коду было сложнее вмешаться в протокол. `await` внутри `lock` запрещён. [Семантика lock](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/lock).

#### 2.92. [Средний] Для чего нужен SemaphoreSlim?

**Ответ:** Он ограничивает число одновременно допущенных операций. `WaitAsync` позволяет дождаться допуска без блокирования ожидающего потока; `SemaphoreSlim(1, 1)` подходит для асинхронного взаимного исключения. В отличие от обычного `lock`, такой семафор не реентерабелен: повторное ожидание из уже защищённого участка может зависнуть. [SemaphoreSlim](https://learn.microsoft.com/en-us/dotnet/api/system.threading.semaphoreslim).

#### 2.93. [Средний] Как правильно освобождать допуск SemaphoreSlim?

**Ответ:** Допуск освобождают в `finally`, но только после успешного ожидания. Поэтому `WaitAsync` располагают перед соответствующим `try`: если ожидание отменится, вызывать `Release` нельзя. Все операции, защищающие один ресурс, должны использовать один общий экземпляр семафора.

```csharp
await gate.WaitAsync(cancellationToken);
try
{
    await UpdateResourceAsync(cancellationToken);
}
finally
{
    gate.Release();
}
```

#### 2.94. [Сложный] Что гарантирует volatile?

**Ответ:** Он ограничивает переупорядочивание операций памяти: чтение имеет acquire-семантику, запись — release-семантику. Он не обеспечивает взаимное исключение или единый глобальный порядок всех обращений и не делает `counter++` атомарным. Описание «всегда немедленно читает последнее значение из RAM» некорректно; для счётчиков обычно нужен `Interlocked`, для связанных изменений — `lock`. [Гарантии volatile](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/volatile).

#### 2.95. [Средний] Делает ли volatile-ссылка объект потокобезопасным?

**Ответ:** Нет. В `volatile List<T> items` правила относятся к чтению и записи ссылки в поле, а не к изменению списка. Одновременные операции с объектом требуют собственной синхронизации или подходящего типа коллекции. Это различие между безопасной передачей ссылки и безопасным использованием доступного через неё состояния.

#### 2.96. [Средний] Какие гарантии даёт ConcurrentDictionary?

**Ответ:** Он координирует поддерживаемые операции над своей структурой, но не делает атомарной произвольную цепочку вызовов. Для условных изменений существуют `TryAdd` и `TryUpdate`. Словарь также не защищает изменяемое состояние объектов, которые хранятся в качестве значений: для него нужен отдельный протокол.

#### 2.97. [Сложный] Гарантирует ли GetOrAdd единственный вызов фабрики?

**Ответ:** Нет. Пользовательская фабрика вызывается вне внутренних блокировок; несколько потоков могут одновременно вычислить значение одного ключа. Вызов может вернуть значение, созданное другим потоком. Поэтому фабрика не должна полагаться на выполнение ровно один раз, особенно если у неё есть внешние побочные эффекты. [Контракт GetOrAdd](https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2.getoradd).

#### 2.98. [Сложный] Как Lazy<T> помогает избежать повторного вычисления в GetOrAdd?

**Ответ:** В словаре можно хранить `Lazy<T>` с режимом `ExecutionAndPublication`, а `Value` читать у экземпляра, который вернул словарь. Тогда конкурирующие обращения к одному сохранённому `Lazy<T>` используют его единственную инициализацию. Отдельно определяют обработку ошибок и удаление ключей: это не гарантия единственного вычисления за всю жизнь приложения. [Режимы Lazy<T>](https://learn.microsoft.com/en-us/dotnet/api/system.threading.lazythreadsafetymode).

### Span, Memory и владение буферами

#### 2.99. [Средний] Для чего нужен Span<T>?

**Ответ:** Он представляет непрерывный участок памяти и позволяет обрабатывать его или получать срез без копирования элементов. Источником может быть массив, `stackalloc` или подходящая unmanaged-память. `Span<T>` — `ref struct`, предназначенный для непосредственной обработки с ограниченным временем жизни.

#### 2.100. [Средний] Чем Memory<T> отличается от Span<T>?

**Ответ:** `Memory<T>` — обычная структура: её можно хранить в объекте и передавать через асинхронные границы. Для непосредственной обработки получают `.Span`. Само представление не означает владения памятью; при явном владении нужен отдельный контракт, например `IMemoryOwner<T>`. [Span и Memory](https://learn.microsoft.com/en-us/dotnet/standard/memory-and-spans/memory-t-usage-guidelines).

#### 2.101. [Средний] Делают ли ReadOnlySpan<T> и ReadOnlyMemory<T> данные неизменяемыми?

**Ответ:** Они ограничивают запись через данное представление, но не гарантируют, что исходный буфер не изменит другой владелец ссылки. Для строки типичный вариант — `ReadOnlySpan<char>`. Доступность только для чтения и глубокая неизменяемость — разные свойства.

#### 2.102. [Сложный] Почему у Span<T> есть ограничения времени жизни?

**Ответ:** Он может ссылаться на стековую память. Компилятор предотвращает выход такого представления за допустимое время жизни: нельзя вернуть span на локальный `stackalloc`, упаковать span в `object`, захватить его в замыкании или сохранить в обычном классе. Span на созданный в методе managed-массив вернуть можно: он поддерживает доступность массива.

#### 2.103. [Сложный] Можно ли использовать Span<T> внутри async-метода?

**Ответ:** Начиная с C# 13 локальный `ref struct` допустим в подходящем синхронном участке async-метода. Его нельзя сохранять как состояние через границу `await`. Для передачи буфера между асинхронными этапами используют `Memory<T>`, получая span на время синхронной обработки. [Ограничения ref struct](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/ref-struct).

#### 2.104. [Сложный] Может ли маленький срез удерживать большой массив?

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

#### 2.105. [Средний] Для чего нужен ArrayPool<T>?

**Ответ:** Пул переиспользует массивы и может снизить число аллокаций и нагрузку на GC. `Rent(minimumLength)` возвращает массив не меньше нужной длины, возможно большего размера; его содержимое нельзя считать нулевым. Сам пул удерживает память и требует дисциплины владения, поэтому выгоду подтверждают измерениями.

#### 2.106. [Сложный] Когда арендованный массив можно вернуть в пул?

**Ответ:** После завершения всех операций, которые используют массив или созданные из него `Span`/`Memory`. Массив возвращают тому же пулу ровно один раз, обычно в `finally`. После `Return` доступ недопустим: буфер уже может использовать другой потребитель, даже если у первого сохранилась ссылка.

#### 2.107. [Сложный] Как очищать чувствительные данные в арендованном массиве?

**Ответ:** `Return(..., clearArray: true)` очищает массив, если пул сохраняет его для повторного использования. Если нужно очистить буфер независимо от решения пула, явную очистку выполняют до возврата. Не следует считать содержимое повторно арендованного массива заведомо пустым. [Контракт ArrayPool.Return](https://learn.microsoft.com/en-us/dotnet/api/system.buffers.arraypool-1.return?view=net-10.0).

<a id="aspnet"></a>

## 3. ASP.NET Core

### Конвейер обработки запроса

#### 3.1. [Базовый] Что такое middleware?

**Ответ:** Это компонент конвейера HTTP-запроса. Он может выполнить действия до и после следующего компонента либо завершить обработку самостоятельно. Компоненты вызываются в порядке регистрации, а код после `await next(...)` выполняется при возврате по конвейеру в обратном порядке.

#### 3.2. [Средний] Почему важен порядок middleware?

**Ответ:** Компонент может использовать результат работы предыдущего. Типичная последовательность для API: обработка ошибок → routing → CORS, если нужен → authentication → authorization → endpoint. Routing выбирает endpoint, authentication устанавливает пользователя, authorization проверяет доступ. Часть компонентов `WebApplication` может добавлять автоматически. [Middleware](https://learn.microsoft.com/aspnet/core/fundamentals/middleware).

#### 3.3. [Средний] Чем middleware отличается от MVC-фильтра?

**Ответ:** Middleware работает на уровне HTTP-конвейера. MVC-фильтры выполняются внутри обработки MVC-запроса и имеют доступ к соответствующему контексту: action, аргументам или результату. Поэтому общая обработка HTTP-запросов обычно относится к middleware, а логика, зависящая от этапа MVC, может относиться к фильтрам. [Фильтры MVC](https://learn.microsoft.com/en-us/aspnet/core/mvc/controllers/filters?view=aspnetcore-10.0).

#### 3.4. [Средний] Перехватит ли exception filter ошибку произвольного middleware?

**Ответ:** Нет: exception filter ограничен определёнными этапами MVC-конвейера. Для общей обработки исключений HTTP-конвейера используют middleware, расположенный раньше защищаемых компонентов. После начала отправки ответа заменить его статус и тело уже нельзя так же свободно, как до отправки.

### Аутентификация и авторизация

#### 3.5. [Базовый] Чем authentication отличается от authorization?

**Ответ:** Authentication проверяет удостоверение пользователя и формирует его identity и claims. Authorization определяет, разрешена ли ему конкретная операция. Успешная аутентификация, в том числе проверка JWT, сама по себе не предоставляет доступ ко всем данным и действиям.

#### 3.6. [Базовый] Чем HTTP 401 отличается от HTTP 403?

**Ответ:** Для обычного API с bearer-аутентификацией `401` означает отсутствие подходящей аутентификации, например из-за недействительного токена. `403` означает, что аутентифицированный пользователь не удовлетворяет требованиям доступа. В ASP.NET Core этим ситуациям соответствуют challenge и forbid; конкретное HTTP-поведение зависит от схемы аутентификации и настроек. [Authentication, challenge и forbid](https://learn.microsoft.com/en-us/aspnet/core/security/authentication/?view=aspnetcore-10.0).

#### 3.7. [Средний] Что такое авторизация на уровне ресурса?

**Ответ:** Это проверка права пользователя на конкретный объект, например заказ своей организации. `[Authorize]` проверяет требования endpoint, но сам по себе такую проверку не обеспечивает. Используют авторизацию загруженного ресурса либо выборку, ограниченную разрешёнными данными. Проверка только на фронтенде API не защищает. [Авторизация ресурса](https://learn.microsoft.com/en-us/aspnet/core/security/authorization/resource-based?view=aspnetcore-10.0).

### Время жизни зависимостей

#### 3.8. [Базовый] Чем отличаются Transient, Scoped и Singleton?

**Ответ:** `Transient` создаётся при каждом разрешении зависимости. `Scoped` — один экземпляр на scope, в обычном HTTP-запросе ASP.NET Core это scope запроса. `Singleton` — один экземпляр на соответствующую регистрацию в контейнере, обычно на время жизни приложения. Контейнер не делает состояние singleton автоматически потокобезопасным. [DI и lifetime](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-10.0).

#### 3.9. [Средний] Почему нельзя напрямую внедрять scoped DbContext в singleton?

**Ответ:** Singleton захватит зависимость с более коротким временем жизни — это captive dependency. Проверка scope может обнаружить ошибку; без неё контекст может жить слишком долго и использоваться конкурентно. Для фоновой операции создают отдельный scope через `IServiceScopeFactory` либо контекст через `IDbContextFactory<TContext>`, освобождая его после завершения работы.

#### 3.10. [Средний] Как получить scoped-сервис в обычном middleware?

**Ответ:** В обычном middleware, создаваемом при запуске приложения, scoped-зависимость получают параметром `InvokeAsync`, чтобы использовать scope текущего запроса. Другой вариант — middleware на основе `IMiddleware`, создаваемый фабрикой с подходящим временем жизни.

<a id="sql"></a>

## 4. SQL

### Соединения, NULL и агрегаты

#### 4.1. [Базовый] Чем INNER JOIN отличается от LEFT JOIN?

**Ответ:** `INNER JOIN` возвращает сочетания строк, удовлетворяющие условию соединения. `LEFT JOIN` дополнительно сохраняет строки левой таблицы без совпадений, заполняя поля правой стороны значением `NULL`. Если справа несколько совпадений, одна левая строка попадает в несколько строк результата; это важно при расчёте агрегатов.

#### 4.2. [Базовый] Что означает NULL?

**Ответ:** `NULL` обозначает отсутствие известного значения. Для проверки используют `IS NULL`, а не `= NULL`: обычное сравнение с `NULL` даёт `UNKNOWN`. `WHERE` пропускает только строки, для которых условие истинно, поэтому строки с результатом `UNKNOWN` отбрасываются. [NULL и трёхзначная логика](https://learn.microsoft.com/en-us/sql/t-sql/language-elements/null-and-unknown-transact-sql?view=sql-server-ver17).

#### 4.3. [Базовый] Чем COUNT(*) отличается от COUNT(column)?

**Ответ:** `COUNT(*)` считает строки результата. `COUNT(column)` считает только значения столбца, отличные от `NULL`; числовой ноль при этом учитывается. После `LEFT JOIN` это различие позволяет отличить строку клиента без заказа от действительно найденного заказа.

#### 4.4. [Базовый] Чем WHERE отличается от HAVING?

**Ответ:** `WHERE` логически отбирает строки до группировки. `HAVING` фильтрует группы по условиям, например `HAVING COUNT(*) > 3`. Это логический порядок обработки; физический план выполнения СУБД может организовать иначе. [Обработка SELECT](https://learn.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql?view=sql-server-ver17).

#### 4.5. [Средний] Как условие по правой таблице в WHERE влияет на LEFT JOIN?

**Ответ:** Условие вроде `WHERE o.Status = 'Paid'` отбрасывает строки без правого совпадения: сравнение с `NULL` не истинно. Если нужно сохранить всех клиентов и присоединить только оплаченные заказы, такой фильтр размещают в условии `ON`.

### Индексы и выполнение запросов

#### 4.6. [Базовый] Зачем нужен индекс?

**Ответ:** Обычный B-tree/B+tree-индекс помогает искать отдельные значения и диапазоны, а иногда избегать сортировки или чтения основной таблицы. Он занимает место и требует обслуживания при изменении данных. Поэтому увеличение числа индексов ускоряет не любую нагрузку и может замедлить запись.

#### 4.7. [Средний] Почему важен порядок столбцов составного индекса?

**Ответ:** Он определяет порядок данных в индексе и доступные способы поиска. Для условия равенства по `CustomerId` и диапазона по `CreatedAt` часто полезен `(CustomerId, CreatedAt)`: сначала равенство, затем диапазон. Индекс `(CreatedAt, CustomerId)` не равнозначен ему; выбор проверяют на конкретных запросах.

#### 4.8. [Средний] Почему функция над столбцом может мешать индексному поиску?

**Ответ:** Условие может перестать напрямую задавать диапазон значений индексированного столбца. Например, вместо `YEAR(CreatedAt) = 2025` обычно удобнее для поиска полуинтервал `CreatedAt >= @start AND CreatedAt < @end`. Возможность и пользу такого поиска проверяют по плану выполнения.

#### 4.9. [Средний] Почему СУБД может не использовать подходящий индекс?

**Ответ:** При низкой селективности, маленькой таблице или дорогих дополнительных чтениях scan может оказаться дешевле. Наличие индекса не гарантирует seek и ускорение. Решение оценивают по фактическому плану, чтениям и времени на реалистичных данных. [Проектирование индексов SQL Server](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-index-design-guide?view=sql-server-ver17).

#### 4.10. [Средний] Что такое покрывающий индекс?

**Ответ:** Это индекс, содержащий все нужные запросу данные, благодаря чему можно избежать дополнительных обращений к основной таблице. В SQL Server возвращаемые столбцы можно включить через `INCLUDE`, не добавляя их в ключ поиска. Цена — размер индекса и дополнительные затраты при записи.

### Транзакции и изоляция

#### 4.11. [Базовый] Что такое транзакция?

**Ответ:** Транзакция объединяет операции с данными в единицу работы: изменения фиксируют через commit или отменяют через rollback. Она позволяет задавать границу атомарности нескольких изменений. Взаимодействие с параллельными транзакциями зависит от уровня изоляции и поведения конкретной СУБД.

#### 4.12. [Базовый] Что означает ACID?

**Ответ:** Атомарность — изменения транзакции применяются целиком или откатываются. Согласованность — сохраняются заданные ограничения данных. Изоляция — ограничивается влияние параллельных транзакций. Долговечность — подтверждённые изменения сохраняются в соответствии с гарантиями СУБД. Транзакция не заменяет корректную реализацию бизнес-правил.

#### 4.13. [Средний] Чем READ COMMITTED отличается от READ UNCOMMITTED?

**Ответ:** В SQL Server `READ UNCOMMITTED` допускает dirty read — чтение ещё незафиксированных изменений. `READ COMMITTED` запрещает такое чтение, но повторный запрос внутри одной транзакции может увидеть другие значения или набор строк. Это уровень по умолчанию в SQL Server; детали реализации зависят от настроек.

#### 4.14. [Средний] Что гарантирует REPEATABLE READ в SQL Server?

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

#### 4.15. [Сложный] Что гарантирует SERIALIZABLE в SQL Server?

**Ответ:** Помимо прочитанных строк защищаются соответствующие диапазоны, предотвращая фантомы. Результат соответствует некоторому последовательному исполнению транзакций. Такая изоляция ограничивает конкурентность; возможны блокировки и взаимоблокировки. [Уровни изоляции SQL Server](https://learn.microsoft.com/en-us/sql/t-sql/statements/set-transaction-isolation-level-transact-sql?view=sql-server-ver17).

#### 4.16. [Сложный] Чем READ_COMMITTED_SNAPSHOT отличается от SNAPSHOT?

**Ответ:** В SQL Server при включённом `READ_COMMITTED_SNAPSHOT` чтение на уровне `READ COMMITTED` использует версии строк и согласованный снимок отдельного statement. `SNAPSHOT` даёт снимок на уровне транзакции. При выключенном RCSI обычное `READ COMMITTED` опирается на блокировки чтения; эти детали нельзя автоматически переносить на другие СУБД.

#### 4.17. [Сложный] Предотвращает ли READ COMMITTED потерянное обновление?

**Ответ:** Само наличие такой транзакции не защищает схему «прочитал — вычислил — записал» от потери чужого изменения. В зависимости от задачи используют подходящий уровень изоляции, атомарный `UPDATE` либо проверку версии строки. Нужно защищать всю бизнес-операцию, а не только отдельный SQL-вызов.

### Небольшая практическая задача

#### 4.18. [Базовый] Как посчитать количество и сумму оплаченных заказов каждого клиента?

**Время:** 5–10 минут. Задача использует общее подмножество SQL, подходящее для SQL Server и PostgreSQL.

Есть две таблицы:

- `Customers`: `Id` — первичный ключ, `Name` — обязательная строка.
- `Orders`: `Id` — первичный ключ, `CustomerId` — обязательный внешний ключ на клиента, `Amount` — обязательный `decimal(12, 2)`, `Status` — обязательная строка. Денежная сумма не хранится в `float`.

**Customers**

| Id | Name |
| --- | --- |
| 1 | Анна |
| 2 | Борис |
| 3 | Анна |
| 4 | Вера |

**Orders**

| Id | CustomerId | Amount | Status |
| --- | --- | ---: | --- |
| 101 | 1 | 100.00 | Paid |
| 102 | 1 | 250.00 | Paid |
| 103 | 1 | 900.00 | Cancelled |
| 104 | 2 | 500.00 | New |
| 105 | 3 | 80.00 | Paid |

**Условие:** Напишите один запрос, возвращающий `CustomerId`, `Name`, количество оплаченных заказов `PaidOrderCount` и их сумму `PaidTotal` для **каждого** клиента. Оплаченными считаются только заказы со статусом `Paid`. Клиенты без оплаченных заказов должны остаться в результате с нулями. Отсортируйте результат по `CustomerId`.

**Ожидаемый результат:**

| CustomerId | Name | PaidOrderCount | PaidTotal |
| --- | --- | ---: | ---: |
| 1 | Анна | 2 | 350.00 |
| 2 | Борис | 0 | 0.00 |
| 3 | Анна | 1 | 80.00 |
| 4 | Вера | 0 | 0.00 |

**Ответ:**

```sql
SELECT
    c.Id AS CustomerId,
    c.Name,
    COUNT(o.Id) AS PaidOrderCount,
    COALESCE(SUM(o.Amount), 0) AS PaidTotal
FROM Customers AS c
LEFT JOIN Orders AS o
    ON o.CustomerId = c.Id
    AND o.Status = 'Paid'
GROUP BY c.Id, c.Name
ORDER BY c.Id;
```

`LEFT JOIN` сохраняет всех клиентов. Статус фильтруется в `ON`, поэтому клиент только с неоплаченными заказами также остаётся. `COUNT(o.Id)` не считает строку без заказа; `COUNT(*)` ошибочно дал бы для неё единицу. `SUM` без значений, отличных от `NULL`, возвращает `NULL`, который `COALESCE` заменяет на ноль. Группировка по идентификатору не объединяет разных клиентов с одинаковыми именами.

Чтобы оставить только клиентов хотя бы с двумя оплаченными заказами, после `GROUP BY` и перед `ORDER BY` добавляют `HAVING COUNT(o.Id) >= 2`. Для приведённых данных останется только клиент с идентификатором `1`.

<a id="efcore"></a>

## 5. Entity Framework Core

### Контекст и отслеживание изменений

#### 5.1. [Базовый] Для чего нужен DbContext?

**Ответ:** `DbContext` представляет сессию работы с БД: позволяет выполнять запросы, отслеживать состояние сущностей и сохранять изменения. Обычно его время жизни соответствует одной единице работы. Контекст не предназначен для бессрочного хранения всего загруженного графа объектов.

#### 5.2. [Средний] Можно ли параллельно использовать один DbContext?

**Ответ:** Нет: `DbContext` не потокобезопасен и не допускает несколько одновременно выполняющихся операций. Два запроса через `Task.WhenAll` на одном контексте некорректны даже без явного создания потоков. Нужно дождаться завершения операции либо использовать независимые контексты. [Использование DbContext](https://learn.microsoft.com/en-us/ef/core/dbcontext-configuration/).

#### 5.3. [Базовый] Что такое change tracking?

**Ответ:** При обычном tracking-запросе сущности с ключом попадают в change tracker. Контекст отслеживает их состояние, а `SaveChanges` обнаруживает и сохраняет изменения. Для одного типа сущности и ключа tracking использует один экземпляр объекта — это identity resolution.

#### 5.4. [Средний] Когда использовать AsNoTracking?

**Ответ:** Когда загруженные сущности не планируется изменять и сохранять через этот контекст. Не создаётся обычное отслеживание для сохранения изменений. Это не универсальная гарантия меньших затрат: если одна сущность повторяется в результате, без identity resolution могут создаваться разные экземпляры объекта.

#### 5.5. [Средний] Для чего нужен AsNoTrackingWithIdentityResolution?

**Ответ:** Он устраняет повторные экземпляры одной сущности внутри результата, но не прикрепляет сущности к основному change tracker контекста. Это позволяет получить identity resolution без обычного отслеживания последующих изменений через этот контекст. [Tracking и identity resolution](https://learn.microsoft.com/en-us/ef/core/querying/tracking).

#### 5.6. [Средний] Гарантирует ли проекция в DTO отсутствие tracking?

**Ответ:** Если результат содержит только скалярные данные, сущности не отслеживаются. Но проекция может содержать саму сущность, например `Select(x => new { Entity = x, ... })`. В таком случае она по умолчанию будет отслеживаться; важен состав результата, а не его название.

### Загрузка данных и производительность

#### 5.7. [Базовый] Какие есть способы загрузки связанных сущностей?

**Ответ:** Eager loading загружает связи как часть запроса, например через `Include`. Explicit loading выполняет отдельный явный вызов загрузки. Lazy loading при соответствующей настройке инициирует загрузку при обращении к навигационному свойству. Выбор влияет на количество запросов и момент обращения к БД.

#### 5.8. [Средний] Что такое проблема N+1?

**Ответ:** Сначала выполняется запрос за списком родительских сущностей, затем дополнительный запрос для каждого элемента. Диагностируют количество SQL-команд и объём данных. Для API часто полезнее сразу спроецировать нужные поля и агрегаты в DTO, чем загружать полный граф; при необходимости связанных сущностей используют подходящую предварительную загрузку. [Эффективные запросы](https://learn.microsoft.com/en-us/ef/core/performance/efficient-querying).

#### 5.9. [Средний] Почему несколько Include могут сделать запрос тяжёлым?

**Ответ:** При загрузке нескольких коллекций одного уровня сочетания их элементов размножают строки результата. Например, 10 заказов и 5 адресов одного клиента могут дать 50 сочетаний с повторением данных. Поэтому добавление `Include` не является универсальным исправлением любого медленного запроса.

#### 5.10. [Средний] Для чего нужен AsSplitQuery?

**Ответ:** Он позволяет загружать коллекции отдельными запросами и уменьшать размножение строк при соединениях. Цена — дополнительные обращения к БД и возможность прочитать части графа из разных состояний данных. Выбор между проекцией, единым запросом и split query проверяют измерениями. [Single и split queries](https://learn.microsoft.com/en-us/ef/core/querying/single-split-queries).

#### 5.11. [Сложный] Гарантирует ли AsSplitQuery согласованный снимок всего графа?

**Ответ:** Нет. Между отдельными запросами другая транзакция может изменить данные. Если требуется согласованность чтения всего графа, нужна подходящая транзакция, например snapshot или serializable с учётом конкретной СУБД и стоимости выбранного уровня изоляции.

### Сохранение и конкурентные изменения

#### 5.12. [Средний] Что гарантирует один вызов SaveChanges?

**Ответ:** При стандартных настройках и поддержке транзакций провайдером изменения одного вызова применяются атомарно. Несколько последовательных `SaveChanges` сами по себе не образуют общую транзакцию. Если нужна общая атомарность, транзакцию задают явно и согласуют с используемой стратегией повторов. [Транзакции EF Core](https://learn.microsoft.com/en-us/ef/core/saving/transactions).

#### 5.13. [Сложный] Как EF Core обнаруживает конкурентное изменение строки?

**Ответ:** Настраивается concurrency token. EF добавляет его исходное значение в условие `UPDATE` или `DELETE` вместе с ключом. Если ожидаемая строка не обновилась, возникает `DbUpdateConcurrencyException`: данные могли быть изменены или удалены другой операцией. Без настроенного контроля версии обычный `SaveChanges` не гарантирует обнаружение потерянного обновления.

#### 5.14. [Средний] Что такое rowversion в SQL Server?

**Ответ:** Это обновляемый базой маркер версии строки, удобный как concurrency token. Он не является датой или временем. В других СУБД механизм может отличаться; при необходимости токеном версии управляет приложение. [Оптимистическая конкуренция EF Core](https://learn.microsoft.com/en-us/ef/core/saving/concurrency).

#### 5.15. [Сложный] Как обрабатывать DbUpdateConcurrencyException?

**Ответ:** Перечитать актуальные данные, определить, как объединить либо отклонить изменения, обновить исходный token и при необходимости повторить бизнес-операцию. Слепой повтор `SaveChanges` не разрешает конфликт. Повтор временного сетевого сбоя — отдельная задача; транзакция БД также не откатывает уже отправленный email или внешний HTTP-вызов.
