Библиотека интервьюераSenior · 12

Собеседование на час

Готовый маршрут на 60 минут: ключевые вопросы, ответы, тайминг и небольшая SQL-задача.

План на 60 минут

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

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

Минуты от началаБлокДлительность
00–02Знакомство: текущий проект и личная зона ответственности2 мин
02–07ООП и проектирование — вопросы 1.1–1.25 мин
07–36C#/.NET — вопросы 2.1–2.629 мин
36–41ASP.NET Core — вопрос 3.15 мин
41–44SQL: индексы — вопрос 4.13 мин
44–52SQL: небольшая задача — вопрос 4.28 мин
52–57EF Core — вопрос 5.15 мин
57–60Резерв и вопросы кандидата3 мин
Всего60 мин
01 / ТЕМА

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

2 вопроса

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.

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

02 / ТЕМА

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

6 вопросов

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?

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 не решает проблему?

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

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

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> запрещает запись через данное представление, но не гарантирует неизменяемость исходного массива.

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

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

03 / ТЕМА

ASP.NET Core — 5 минут

1 вопрос

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 не считается исправлением.

04 / ТЕМА

SQL — 11 минут

2 вопроса

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

IdName
1Анна
2Иван
3Анна
4Олег

Orders

IdCustomerIdAmountStatus
1011100.00Paid
1021250.00Paid
1031900.00Cancelled
1042500.00New
105380.00Paid

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

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

CustomerIdNamePaidOrderCountPaidTotal
1Анна2350.00
2Иван00.00
3Анна180.00
4Олег00.00

Ответ:

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.

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

05 / ТЕМА

Entity Framework Core — 5 минут

1 вопрос

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 при выборе альтернативного вопроса само по себе не определяет итоговый уровень.