# Senior fullstack: backend-собеседование на 60 минут

Сценарий для интервьюера: **12 основных вопросов и заданий**, ответы и короткие уточнения. Темы — ООП и проектирование, C#/.NET, ASP.NET Core, SQL, EF Core. На C#/.NET отведено 29 минут. Это сокращённая версия [полного банка вопросов](full.md).

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

| Минуты от начала | Блок | Длительность |
| --- | --- | ---: |
| 00–02 | Знакомство: текущий проект и личная зона ответственности | 2 мин |
| 02–07 | ООП и проектирование — вопросы 1.1–1.2 | 5 мин |
| 07–36 | C#/.NET — вопросы 2.1–2.6 | 29 мин |
| 36–41 | ASP.NET Core — вопрос 3.1 | 5 мин |
| 41–44 | SQL: индексы — вопрос 4.1 | 3 мин |
| 44–52 | SQL: небольшая задача — вопрос 4.2 | 8 мин |
| 52–57 | EF Core — вопрос 5.1 | 5 мин |
| 57–60 | Резерв и вопросы кандидата | 3 мин |
| **Всего** | | **60 мин** |

## 1. ООП и проектирование — 5 минут

### 1.1. Что такое ООП? — 2 минуты

**Вопрос:** Что такое объектно-ориентированное программирование? Какие у него основные принципы?

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

- **Абстракция** — выделение существенных для задачи свойств и операций, позволяющее работать с понятной моделью без знания всех деталей реализации.
- **Инкапсуляция** — управление доступом к состоянию и деталям реализации через определённый интерфейс, чтобы сохранять корректность объекта и его инварианты.
- **Наследование** — создание производного типа на основе базового с наследованием его контракта и доступной реализации.
- **Полиморфизм** — возможность работать с разными реализациями через общий контракт; конкретное поведение определяется реализацией.

**Уточнение:** Чем абстракция отличается от инкапсуляции?

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

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

### 1.2. Что такое SOLID? — 3 минуты

**Вопрос:** Что такое SOLID? Расшифруйте пять принципов и объясните смысл каждого.

**Ответ:** SOLID — пять принципов проектирования, которые помогают разделять обязанности, уменьшать связанность и упрощать изменение кода:

- **S — Single Responsibility Principle, принцип единственной ответственности.** У модуля должна быть одна связная ответственность: вместе находится то, что меняется по одной причине; независимые причины изменений разделяются.
- **O — Open/Closed Principle, принцип открытости/закрытости.** Модуль открыт для расширения поведения и закрыт для изменений в своей стабильной части при таком расширении. Это не запрет исправлять или перерабатывать существующий код.
- **L — Liskov Substitution Principle, принцип подстановки Лисков.** Подтип должен сохранять обещания контракта базового типа, чтобы клиент мог использовать его без нарушения ожидаемого поведения. Нельзя усиливать предусловия или ослаблять постусловия.
- **I — Interface Segregation Principle, принцип разделения интерфейсов.** Клиенты не должны зависеть от операций, которые им не нужны. Контракты выделяют по потребностям клиентов.
- **D — Dependency Inversion Principle, принцип инверсии зависимостей.** Высокоуровневая логика и низкоуровневые компоненты зависят от абстракций. Детали реализации подчиняются этим абстракциям; абстракции не зависят от деталей.

**Уточнение:** Чем DIP отличается от DI?

**Ответ на уточнение:** DIP — принцип направления зависимостей. DI, dependency injection, — способ передавать объекту зависимости извне, например через конструктор. DI можно использовать без контейнера; само внедрение зависимости ещё не гарантирует соблюдение DIP.

**Признак сильного ответа:** кандидат объясняет назначение всех пяти принципов и отличает принцип проектирования от способа его реализации.

## 2. C#/.NET — 29 минут

### 2.1. Что именно копируется у value и reference types? — 4 минуты

**Вопрос:** Чем отличаются значимые и ссылочные типы? Если скопировать структуру, внутри которой находится `List<int>`, получится ли независимый список? Что может изменить метод, принимающий объект обычным параметром?

**Ответ:** Присваивание значимого типа копирует значение; присваивание ссылочного — ссылку на объект. Копирование структуры поверхностное: поле-ссылка копируется, поэтому обе структуры указывают на один список.

По умолчанию параметры передаются по значению, в том числе ссылки. Метод может изменить доступное состояние объекта, но присваивание параметру нового объекта не заменит переменную вызывающего кода. Для доступа к самой переменной применяют `ref`; `out` требует присвоить результат при нормальном возврате, `in` предоставляет доступ по ссылке только для чтения.

Разделение «значимые типы всегда в стеке, ссылочные всегда в куче» неверно: структура может быть полем объекта в куче, а локальное значение — находиться в регистре.

**Уточнение:** Сделает ли `readonly struct` вложенный список неизменяемым?

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

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

### 2.2. Как Dictionary использует Equals и GetHashCode? — 5 минут

**Вопрос:** Как словарь находит значение по ключу? Что происходит при одинаковых хешах? Почему после изменения ключа запись иногда перестаёт находиться?

**Ответ:** `Dictionary<TKey, TValue>` — хеш-таблица. По хешу выбирается корзина, затем ключ сравнивается с кандидатами через используемый comparer. **Равные ключи обязаны иметь одинаковые хеши; одинаковый хеш не означает равенство.** Коллизии нормальны и сами по себе не приводят к потере записи.

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

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

**Уточнение:** Корректен ли `GetHashCode() => 1`?

**Ответ на уточнение:** Контракт равенства не нарушен, но все ключи сталкиваются. Правильность сравнения сохраняется, производительность резко ухудшается.

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

### 2.3. Что происходит при async/await и почему опасен .Result? — 6 минут

**Вопрос:** Endpoint вызывает внешний HTTP API. Создаёт ли `async` новый поток? Нужен ли `Task.Run` вокруг асинхронного запроса? Что изменится, если вместо `await` использовать `.Result`?

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

Во время асинхронного I/O `await` не удерживает поток только ради ожидания ответа. Оборачивать уже асинхронный HTTP-вызов в `Task.Run` обычно незачем. Он отправляет работу в пул и полезен, например, для выноса CPU-вычислений из UI-потока; на сервере перенос работы между потоками пула сам по себе не добавляет мощности.

`.Result` блокирует поток. В UI возможен deadlock, когда продолжению нужен занятый UI-контекст. У ASP.NET Core собственного контекста синхронизации запроса по умолчанию нет, но массовые блокирующие ожидания приводят к истощению пула потоков и росту задержек. Решение — асинхронная цепочка вызовов.

**Уточнение:** Исправляет ли `.GetAwaiter().GetResult()` эту проблему?

**Ответ на уточнение:** Нет. Он иначе распространяет исключение: исходная ошибка вместо обёртки `AggregateException`, характерной для `.Result`/`.Wait()`. Синхронная блокировка остаётся.

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

### 2.4. Как исправить гонку и выбрать средство синхронизации? — 5 минут

**Вопрос:** Гарантирует ли этот код вывод `10000`? Как исправить его? Какое средство использовать, если защищаемая операция содержит `await`?

```csharp
int counter = 0;
Parallel.For(0, 10_000, _ => counter++);
Console.WriteLine(counter);
```

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

Когда нужно согласованно проверить и изменить несколько связанных полей, обычно проще один `lock` вокруг всей операции. Чтение согласованного состояния также должно следовать выбранному протоколу. `volatile` не превращает `counter++` в атомарную операцию.

Внутри `lock` нельзя использовать `await`. Для асинхронного взаимного исключения подходит общий `SemaphoreSlim(1, 1)`: сначала `await gate.WaitAsync(token)`, затем защищаемая работа в `try`, а `gate.Release()` — в `finally`. Если ожидание отменилось до получения допуска, освобождать его нельзя.

**Уточнение:** Сам по себе `Task.WhenAll` ограничит количество одновременно выполняемых HTTP-запросов?

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

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

### 2.5. Найдите ошибку во времени жизни ресурса — 5 минут

**Вопрос:** Что не так с методом? Почему наличие GC не решает проблему?

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

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

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

GC отвечает за управляемую память, а `Dispose` — за своевременное освобождение ресурсов. `using` организует вызов `Dispose`, в том числе при обычном выходе из области из-за исключения; для асинхронного освобождения через `IAsyncDisposable` существует `await using`. Прямой возврат задачи допустим в простом методе-переадресаторе, если не требуется удерживать ресурс или обрабатывать последующую ошибку.

**Уточнение:** Поймает ли `try { return OperationAsync(); } catch { ... }` ошибку, возникшую позже?

**Ответ на уточнение:** Нет. Он ловит только синхронное исключение при получении задачи. Для обработки ошибки завершения нужен `await` внутри `try`.

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

### 2.6. Где и когда выполняется LINQ-запрос? — 4 минуты

**Вопрос:** Чем отличаются `IEnumerable<T>` и `IQueryable<T>`? Что произойдёт, если перед фильтрацией запроса EF вызвать `AsEnumerable()`? Что даёт `ToList()`?

**Ответ:** `IEnumerable<T>` задаёт перечисление; это не обещание, что данные уже загружены. `IQueryable<T>` представляет запрос деревом выражений, которое провайдер может перевести в SQL. Многие операции, например `Where` и `Select`, выполняются отложенно — при перечислении.

`AsEnumerable()` сам по себе не загружает все данные, но последующие LINQ-операторы выбираются как операции над `IEnumerable`. В результате фильтр, который мог выполняться в БД, может начать выполняться в приложении после передачи лишних строк.

`ToList()` выполняет запрос и материализует результат. Это предотвращает повторный запрос при повторном обходе полученного списка, но требует памяти и полного чтения результата. Обычно фильтрацию, проекцию и ограничение объёма нужно выразить до материализации.

**Уточнение:** Всегда ли отложенное выполнение означает обработку по одному элементу без буферизации?

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

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

#### Замена вопроса 2.6: Span и Memory — те же 4 минуты

Выберите этот вариант вместо LINQ, если кандидат заявляет опыт оптимизации памяти или высоких нагрузок. Оба варианта подряд в план часа не входят.

**Вопрос:** Зачем нужны `Span<T>` и `Memory<T>`? Как передать буфер между асинхронными этапами? Когда можно вернуть арендованный массив в `ArrayPool<T>`?

**Ответ:** Это представления участков памяти; создание среза не требует копирования элементов. `Span<T>` — `ref struct` для непосредственной обработки, его нельзя хранить в обычном объекте или переносить как состояние через `await`. Начиная с C# 13 локальный span допустим в подходящем синхронном участке async-метода. `Memory<T>` можно хранить в объекте и передавать через асинхронные границы, получая `.Span` на время обработки.

Представление не владеет буфером. Массив возвращают пулу только после завершения всех операций, использующих его; после возврата нельзя использовать и созданные из него `Memory`/`Span`. `ReadOnlyMemory<T>` запрещает запись через данное представление, но не гарантирует неизменяемость исходного массива.

**Уточнение:** Может ли маленький срез удерживать большой массив?

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

## 3. ASP.NET Core — 5 минут

### 3.1. Можно ли передать DbContext в singleton-сервис? — 5 минут

**Вопрос:** Сервис зарегистрирован как singleton и получает `DbContext` через конструктор. В чём проблема? Объясните Transient, Scoped, Singleton и предложите исправление для фоновой обработки.

**Ответ:** `Transient` создаётся при каждом разрешении зависимости; `Scoped` — один экземпляр на scope, обычно HTTP-запрос; `Singleton` — один экземпляр на соответствующую регистрацию в контейнере.

`AddDbContext` по умолчанию регистрирует контекст как scoped. Singleton захватывает зависимость с более коротким временем жизни — captive dependency. Проверка scope может обнаружить ошибку; без неё контекст способен жить слишком долго и использоваться одновременно разными запросами. `DbContext` не потокобезопасен, несколько параллельных операций на нём недопустимы.

Если сервис работает в рамках запроса, ему может подойти scoped lifetime. Для фоновой работы создают отдельный scope на операцию через `IServiceScopeFactory` либо контекст через `IDbContextFactory<TContext>`, затем корректно освобождают его. Новый контекст нельзя сразу закрывать, пока его асинхронная работа продолжается.

**Уточнение:** Где брать scoped-сервис в обычном middleware, создаваемом при запуске приложения?

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

**Признак сильного ответа:** кандидат обсуждает время жизни и конкурентное использование; замена регистрации контекста на singleton не считается исправлением.

## 4. SQL — 11 минут

### 4.1. Как выбрать индекс и проверить, что он помогает? — 3 минуты

**Вопрос:** Часто выполняется запрос по `CustomerId` и диапазону `CreatedAt`. Какой составной индекс предложите? Почему наличие индекса не гарантирует быстрый запрос?

**Ответ:** Разумный исходный кандидат — `(CustomerId, CreatedAt)`: равенство по клиенту, затем диапазон дат. Порядок ключей важен. Предикат вида `CreatedAt >= @from AND CreatedAt < @to` обычно удобнее для индексного поиска, чем функция над столбцом вроде `YEAR(CreatedAt) = ...`.

Нужно проверить фактический план, число чтений и время на реалистичных данных. При низкой селективности или дорогих дополнительных чтениях таблицы scan может быть выгоднее. Индекс занимает место и увеличивает стоимость записи; его не добавляют автоматически на каждый столбец.

**Уточнение:** Что такое покрывающий индекс?

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

**Признак сильного ответа:** кандидат предлагает проверяемую гипотезу и учитывает нагрузку на запись.

### 4.2. Задача: количество и сумма оплаченных заказов — 8 минут

На знакомство с условием отведите 1 минуту, на решение — около 5, на обсуждение — 2. Подойдёт общее подмножество SQL для SQL Server и PostgreSQL.

**Условие:** Есть `Customers(Id, Name)` и `Orders(Id, CustomerId, Amount, Status)`. `Id` — первичные ключи; `CustomerId` — обязательный внешний ключ. Все поля обязательные, `Amount` имеет тип `decimal(12, 2)`.

**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 |

**Вопрос:** Напишите один запрос, который вернёт идентификатор и имя **каждого** клиента, количество и сумму его заказов со статусом `Paid`. Клиенты без оплаченных заказов должны остаться в результате с нулями. Сортировка — по идентификатору клиента.

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

| 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(*)` посчитал бы строку клиента и дал единицу. `COALESCE` заменяет отсутствующую сумму на ноль. Группировка по идентификатору не объединяет тёзок.

**Уточнение:** Что изменится, если перенести `o.Status = 'Paid'` в `WHERE`?

**Ответ на уточнение:** Клиенты без оплаченных заказов исчезнут: после соединения условие не пропустит строки с `NULL` в полях заказа. Допустимы и другие решения, например предварительная агрегация оплаченных заказов с последующим `LEFT JOIN`.

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

## 5. Entity Framework Core — 5 минут

### 5.1. Почему один endpoint выполняет десятки SQL-запросов? — 5 минут

**Вопрос:** Endpoint загружает 100 заказов, затем обращается к их связанным данным в цикле. При настроенной lazy loading в логах видны десятки дополнительных SQL-запросов. Что произошло и как исправить? Достаточно ли всегда добавить `Include`?

**Ответ:** Это типичный **N+1**: один запрос за основным списком и дополнительные запросы за связями. Сначала нужно подтвердить количество запросов, их SQL, объём данных и время выполнения.

Для ответа API часто лучше сразу спроецировать нужные поля и агрегаты в DTO через `Select`. Если нужны сами связанные сущности, подходит eager loading через `Include`. Но несколько коллекций одного уровня могут многократно размножить строки результата. `AsSplitQuery()` уменьшает такое размножение, выполняя несколько запросов; цена — дополнительные обращения к БД и возможная несогласованность между чтениями без подходящей транзакции.

`AsNoTracking()` уместен для чтения сущностей без дальнейшего сохранения изменений, но не устраняет N+1. Решение выбирают по измерениям и фактическому сценарию, а не по одному универсальному правилу.

**Уточнение:** А если два запроса одновременно редактируют один заказ, защитит ли обычный `SaveChanges` от потери одного изменения?

**Ответ на уточнение:** Сам по себе — нет. Для обнаружения конфликта настраивают concurrency token, например `rowversion` в SQL Server. EF проверяет исходное значение при обновлении и при конфликте бросает `DbUpdateConcurrencyException`. Затем нужно осмысленно разрешить конфликт, перечитать данные или отклонить изменение; слепой повтор не заменяет это решение.

**Признак сильного ответа:** кандидат связывает EF с реальным SQL, разделяет проблемы загрузки, tracking и конкурентного обновления.

---

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