Backend на .NET
От основ ООП до асинхронности и работы с данными. Вопросы, ответы и нюансы для разговора с senior-разработчиком.
Ничего не найдено
Попробуйте другой термин или выберите любую сложность.
Как пользоваться банком
Банк коротких вопросов с ответами для интервьюера. Внутри каждой темы вопросы идут от основных понятий к механизму работы, ограничениям и практическим нюансам. Каждый номер можно задать отдельно; соседние вопросы образуют последовательную беседу.
Метки [Базовый], [Средний], [Сложный] обозначают глубину вопроса. Для senior важны объяснение причин, корректность рассуждений и понимание компромиссов. Не требуется задавать весь банк за одну встречу: для этого есть отдельный сценарий на 60 минут.
Под ASP.NET и EF здесь понимаются ASP.NET Core и Entity Framework Core. Версионные особенности отмечены в соответствующих ответах. В разделе SQL есть одна небольшая задача с исходными данными, ожидаемым результатом и решением.
Темы:
ООП, принципы разработки и проектирования
33 вопроса
Основы ООП
1.1Что такое ООП?Базовый
Ответ: Объектно-ориентированное программирование — парадигма, в которой программа строится вокруг взаимодействующих объектов. Объект объединяет состояние и поведение; его контракт определяет доступные клиенту операции. Основные принципы — абстракция, инкапсуляция, наследование и полиморфизм.
1.2Что такое абстракция?Базовый
Ответ: Абстракция выделяет существенные для задачи свойства и операции, позволяя работать с моделью без знания всех деталей реализации. Например, контракт чтения данных может описывать получение результата, скрывая способ хранения и сетевой протокол.
1.3Что такое инкапсуляция?Базовый
Ответ: Инкапсуляция ограничивает доступ к внутреннему состоянию и реализации, задавая допустимые способы взаимодействия с объектом. Она помогает сохранять инварианты — условия корректности объекта. Публичные свойства с произвольными setter сами по себе этого не обеспечивают. Основы ООП.
1.4Чем инкапсуляция отличается от абстракции?Средний
Ответ: Абстракция определяет, какие возможности существенны и доступны клиенту. Инкапсуляция защищает состояние и детали реализации за этой границей. Эти принципы дополняют друг друга: полезный контракт должен скрывать лишние детали и обеспечивать корректные способы изменения состояния.
1.5Что такое наследование?Базовый
Ответ: Наследование позволяет определить производный тип на основе базового, унаследовав его контракт и доступную реализацию. В C# класс может иметь один непосредственный базовый класс и реализовывать несколько интерфейсов. Наследование предполагает осмысленное отношение подтипа, а не только желание повторно использовать код.
1.6Что такое полиморфизм?Базовый
Ответ: Полиморфизм позволяет работать с разными реализациями через общий контракт. При вызове виртуального метода или реализации интерфейса фактический тип объекта определяет конкретное поведение. Клиенту не требуется перечислять все реализации и выбирать каждую через условие.
1.7Чем абстрактный класс отличается от интерфейса?Средний
Ответ: Абстрактный класс может хранить состояние экземпляра, иметь конструкторы и общую реализацию для семейства типов. Интерфейс задаёт контракт, доступный несвязанным типам; один тип может реализовать несколько интерфейсов. Современные интерфейсы допускают реализации членов по умолчанию, но не поля состояния экземпляра. Интерфейсы C#.
1.8Когда нужен интерфейс для класса?Средний
Ответ: Когда есть осмысленный контракт для клиентов, независимая граница компонентов или необходимость в альтернативном поведении. Автоматическое создание IFoo для каждого Foo не гарантирует хорошей архитектуры. Важны содержание контракта и независимость клиента от деталей реализации.
1.9Что такое перегрузка метода?Базовый
Ответ: Это несколько методов с одинаковым именем и разными сигнатурами. Для обычного статически типизированного вызова перегрузка выбирается при компиляции. Только различия возвращаемого типа недостаточно; вызовы с dynamic имеют отдельные правила разрешения во время выполнения.
1.10Чем override отличается от new при объявлении метода?Средний
Ответ: override переопределяет виртуальный член: при вызове через базовый тип выполняется подходящая реализация по фактическому типу объекта. new скрывает член, объявляя отдельный: выбор при обычном вызове зависит от статического типа выражения. Это разные механизмы, даже если имена методов совпадают. Полиморфизм в C#.
1.11Почему опасен вызов виртуального метода из конструктора?Сложный
Ответ: Вызов может попасть в реализацию наследника до завершения его конструктора. Переопределённый метод получит частично настроенное состояние и может нарушить инварианты или завершиться ошибкой. Поэтому подобную зависимость от поведения наследника обычно исключают из конструирования.
1.12Когда композиция удобнее наследования?Средний
Ответ: При композиции объект использует другие объекты и делегирует им работу. Это удобно, когда части поведения нужно менять независимо, без разрастания иерархии. Наследование уместно при устойчивом отношении подтипа и соблюдении контракта базового типа.
1.13Что означают coupling и cohesion?Средний
Ответ: Coupling — связанность компонентов: сколько знаний друг о друге им требуется и насколько распространяются изменения. Cohesion — связность внутри компонента: насколько его элементы служат одной задаче. Обычно стремятся к низкой внешней связанности и высокой внутренней связности; наличие интерфейса само по себе этого не обеспечивает. Архитектурные принципы.
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.
1.19Что означает принцип разделения интерфейсов — ISP?Средний
Ответ: Клиенты не должны зависеть от операций, которые им не нужны. Контракты разделяют по потребностям клиентов, чтобы изменение одной области не затрагивало всех пользователей большого интерфейса. Само по себе дробление интерфейса до одного метода не является целью.
1.20Что означает принцип инверсии зависимостей — DIP?Средний
Ответ: Высокоуровневая логика и низкоуровневые компоненты должны зависеть от абстракций. Абстракции не зависят от деталей реализации; детали подчиняются абстракциям. Так бизнес-правила можно сохранить при замене инфраструктуры. Пять принципов SOLID.
1.21Чем отличаются IoC и DI?Средний
Ответ: Inversion of Control — более общая идея передачи управления внешнему механизму, например фреймворку. Dependency Injection — способ передавать объекту его зависимости извне, часто через конструктор. DI-контейнер автоматизирует создание графа объектов, но зависимости можно передать и вручную.
1.22Чем DIP отличается от DI?Средний
Ответ: DIP определяет направление зависимостей в проектировании. DI описывает способ предоставления зависимостей объекту. Внедрение конкретного инфраструктурного класса тоже является DI, но само по себе не обеспечивает соблюдения DIP. Dependency injection.
1.23Почему Service Locator может затруднять сопровождение?Средний
Ответ: Когда бизнес-код получает всё через IServiceProvider, его зависимости становятся скрытыми и ошибки конфигурации обнаруживаются позднее. Конструктор делает зависимости явными и упрощает тестирование. Разрешение сервисов через контейнер уместно в инфраструктуре, например при создании scope фоновой операции.
Простота, паттерны и тестирование
1.24Что означает DRY?Базовый
Ответ: Одно и то же знание или правило не должно независимо поддерживаться в нескольких местах. Похожий код не всегда представляет одно знание: если части меняются по разным причинам, их объединение может создать лишнюю связанность. Абстракцию выделяют, когда понятна общая ответственность.
1.25Что означает KISS?Базовый
Ответ: Следует выбирать понятное решение, которое удовлетворяет реальным требованиям без лишней сложности. Простота оценивается по лёгкости понимания и изменения, а не только по числу строк. Дополнительные уровни абстракции должны решать конкретную проблему.
1.26Что означает YAGNI?Базовый
Ответ: Не стоит реализовывать предполагаемые возможности до появления обоснованной потребности. Принцип не отменяет тесты, ясный дизайн и рефакторинг: они помогают изменять систему, когда необходимость возникнет. YAGNI.
1.27Для чего нужен паттерн Strategy?Средний
Ответ: Он выделяет взаимозаменяемые алгоритмы с общим контрактом. Клиент делегирует выбор или выполнение алгоритма стратегии, а разные варианты можно менять независимо. Типичный пример — несколько правил расчёта стоимости доставки.
1.28Для чего нужен паттерн Decorator?Средний
Ответ: Он оборачивает объект с сохранением контракта и добавляет поведение до или после делегированного вызова. Например, измерение времени или кэширование чтения. Нужно сохранять обещания исходного контракта и учитывать порядок нескольких обёрток.
1.29Для чего нужна Factory?Средний
Ответ: Фабрика инкапсулирует создание объекта, если оно зависит от параметров, выбора реализации или дополнительных правил. Она отделяет использование объекта от деталей конструирования. Для простого создания без вариативности отдельная фабрика может быть излишней.
1.30Когда повтор операции после ошибки безопасен?Сложный
Ответ: Нужно понимать, является ли ошибка временной и мог ли побочный эффект уже произойти. Для операций с побочными эффектами важны идемпотентность или механизм предотвращения дубликатов. Число попыток и общее время ограничивают; слепые повторы способны усилить перегрузку. Условия применения retry.
1.31Чем unit-тест отличается от интеграционного?Средний
Ответ: Unit-тест проверяет небольшой законченный фрагмент поведения в изоляции от внешней инфраструктуры. Интеграционный проверяет взаимодействие компонентов, например выполнение запроса через реальный провайдер БД. Они обнаруживают разные классы ошибок и дополняют друг друга.
1.32Что показывает процент покрытия тестами?Средний
Ответ: Он показывает, какой код был выполнен во время тестов, но не доказывает корректность проверок. Важны значимые assertions, граничные случаи, повторяемость и понятные причины падения. Высокое покрытие возможно даже при слабой проверке результата. Качество unit-тестов.
1.33Когда полезно проверять вызовы mock-объекта?Средний
Ответ: Когда взаимодействие само является частью проверяемого контракта, например отправка ровно одной команды. Проверка всех внутренних вызовов привязывает тест к реализации. Обычно предпочтительнее проверять наблюдаемое поведение, чтобы рефакторинг без изменения результата не ломал тесты.
C#/.NET
106 вопросов
Типы, Object и равенство
2.1Чем value types отличаются от reference types?Базовый
Ответ: Переменная значимого типа содержит значение, и присваивание копирует его. Переменная ссылочного типа содержит ссылку на объект, и присваивание копирует ссылку: несколько переменных могут указывать на один объект. К значимым относятся struct и enum, к ссылочным — классы, массивы, строки и делегаты.
2.2Что такое System.Object?Базовый
Ответ: System.Object — корневой базовый класс в иерархии классов .NET; object — его псевдоним в C#. Классы наследуют его прямо или косвенно. Значимые типы также связаны с ним через System.ValueType, но преобразование обычной структуры в object требует упаковки. System.Object.
2.3Какие методы есть у Object?Базовый
Ответ: Основные методы делятся на три группы:
- Публичные методы экземпляра:
Equals(object)проверяет равенство,GetHashCode()возвращает хеш,ToString()— строковое представление,GetType()— фактический тип объекта. Первые три виртуальные;GetType()не виртуальный. - Публичные статические методы:
Equals(object, object)сравнивает значения с обработкойnull,ReferenceEquals(object, object)проверяет идентичность ссылок. - Защищённые методы:
MemberwiseClone()создаёт поверхностную копию,Finalize()участвует в финализации. В C# финализатор объявляют синтаксисом~TypeName(), а не прямым переопределением или вызовомFinalize. Момент его выполнения не определён. Методы Object, финализация.
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#.
2.8Для чего нужен GetHashCode?Базовый
Ответ: Он вычисляет хеш, с помощью которого хеш-коллекции быстро сужают круг кандидатов для сравнения. Хеш не заменяет проверку равенства и не является уникальным идентификатором. Его нельзя сохранять как стабильный отпечаток между запусками: результат может зависеть от процесса и реализации .NET.
2.9Как связаны Equals и GetHashCode?Средний
Ответ: Если два значения равны согласно используемому сравнению, их хеш-коды обязаны совпадать. Обратное неверно: у разных значений могут быть одинаковые хеши. При переопределении Equals нужно согласованно переопределить GetHashCode, обычно по тем же значимым полям; для объединения хешей подходит HashCode.Combine. Контракт 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.
Копирование, размещение и передача параметров
2.17Значимые типы всегда находятся в стеке?Базовый
Ответ: Нет. Структура может быть полем объекта или элементом массива в управляемой куче; локальное значение может находиться в регистре. Ссылка тоже может храниться в поле объекта в куче. Категория типа определяет прежде всего семантику значения, а размещение зависит от контекста и оптимизаций. Типы C#.
2.18Чем поверхностное копирование отличается от глубокого?Базовый
Ответ: При поверхностном копировании копируются значения полей, в том числе ссылки. Поэтому две копии структуры с полем List<int> указывают на один список; аналогично работает MemberwiseClone для полей объекта. Глубокое копирование отдельно копирует нужные вложенные объекты, по правилам конкретной модели данных. MemberwiseClone.
2.19Как параметры передаются по умолчанию?Базовый
Ответ: По значению. Для ссылочного типа копируется ссылка: метод может изменить доступное состояние объекта, но присваивание параметру нового объекта не заменит переменную вызывающего кода. Для структуры копируется сама структура, вместе со значениями её полей.
2.20Для чего нужен ref-параметр?Базовый
Ответ: Он предоставляет доступ к переменной вызывающего кода, позволяя читать и заменять её значение. Переменная должна быть инициализирована до вызова. Для ссылочного типа это позволяет изменить не только объект, но и ссылку, хранящуюся у вызывающего кода.
2.21Для чего нужен out-параметр?Базовый
Ответ: Он позволяет вернуть значение через параметр без требования предварительной инициализации переменной. При нормальном возврате метод обязан присвоить ему значение. Такой контракт используется, например, в TryParse и TryGetValue.
2.22Для чего нужен in-параметр?Средний
Ответ: Он предоставляет доступ по ссылке только для чтения и может уменьшить копирование больших структур. Запрещается изменение самого параметра, но для ссылочного типа доступное состояние объекта остаётся изменяемым. Передача через in не является гарантией ускорения. Параметры методов.
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.
2.28Равны ли два record с разными массивами одинакового содержимого?Средний
Ответ: По умолчанию нет: сгенерированное равенство использует правила сравнения типа каждого поля. Обычный массив сравнивается по ссылке, а не поэлементно. Для равенства по содержимому нужна подходящая собственная модель сравнения.
2.29Что такое boxing?Базовый
Ответ: Boxing — преобразование значения в объектное представление, например при присваивании int переменной object. Обычно создаётся объект с копией значения; последующее изменение исходной структуры не меняет эту копию. Упаковка добавляет расходы на выделение памяти и последующую работу GC.
2.30Что такое unboxing?Средний
Ответ: Это извлечение значимого типа из его упакованного представления. Тип должен соответствовать упакованному: если в object находится int, (long)boxed завершится InvalidCastException. Сначала нужно получить int, затем выполнить обычное числовое преобразование: (long)(int)boxed. Boxing и 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. Сравнение строк.
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.
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.
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.
2.49Нужно ли самостоятельно освобождать объект, полученный из DI?Средний
Ответ: Освобождением обычно управляет владеющий объектом контейнер или scope. Решение зависит от контракта владения: чужой ресурс нельзя закрывать только из-за наличия IDisposable. Отдельно созданным экземпляром, например полученным через фабрику с передачей владения вызывающему коду, нужно управлять согласно контракту этой фабрики.
Делегаты, события и замыкания
2.50Что такое делегат?Базовый
Ответ: Делегат — типизированный вызываемый объект, который хранит метод или список обработчиков с совместимой сигнатурой. Он позволяет передавать поведение как значение. Action<...> представляет вызов без результата, Func<...> — с возвращаемым результатом.
2.51Чем событие отличается от публичного поля-делегата?Средний
Ответ: event ограничивает внешнему коду доступ к подписке и отписке. Клиент не может произвольно заменить весь список обработчиков или вызвать событие. При обычной подписке долгоживущий издатель удерживает делегат, а тот может удерживать подписчика, поэтому жизненным циклом подписки нужно управлять.
2.52Что захватывает замыкание?Средний
Ответ: Замыкание сохраняет доступ к переменным внешней области, а не обязательно их значения на момент создания лямбды. Если переменная изменится, поздний вызов увидит новое значение. Захваченные объекты могут жить дольше, чем ожидается, пока сохраняются ссылки на замыкание.
int number = 1;
Func<int> read = () => number;
number = 2;
Console.WriteLine(read()); // 22.53Что ограничивает static-лямбда?Средний
Ответ: Она запрещает захватывать внешние локальные переменные и состояние экземпляра через this. Это помогает делать зависимости явными и предотвращать случайное удержание объектов замыканием. Доступ к статическим членам при этом остаётся возможен. Лямбды и захват.
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-запросов.
2.58Когда материализация через ToList() полезна?Средний
Ответ: Когда нужен сохранённый результат для повторного обхода или дальнейшей работы после завершения чтения источника. Цена — память и полное получение результата. Фильтрацию и ограничение объёма по возможности применяют до материализации; добавление ToList в произвольное место не является универсальной оптимизацией.
2.59Означает ли отложенное выполнение отсутствие буферизации?Средний
Ответ: Нет. Например, сортировка LINQ to Objects начинается при перечислении, но перед выдачей первого отсортированного элемента должна прочитать исходную последовательность. Отложенность описывает момент начала работы, а потоковая обработка — способ получения результата.
2.60Как работает yield return?Средний
Ответ: Компилятор превращает итератор в автомат состояний. При перечислении yield return выдаёт элемент и сохраняет состояние, следующее продвижение продолжает работу. yield break завершает последовательность. Тело итератора и его исключения обычно проявляются при перечислении; для немедленной проверки аргументов используют внешний обычный метод.
2.61Когда освобождаются ресурсы итератора?Средний
Ответ: Ресурс, открытый внутри итератора через using, остаётся открытым между выдачей элементов. Он освобождается при завершении или корректном освобождении перечислителя. foreach освобождает подходящий перечислитель и при break; при ручном обходе за это отвечает вызывающий код. Итераторы.
Исключения
2.62Где следует перехватывать исключение?Базовый
Ответ: Там, где можно восстановиться, преобразовать ошибку в понятный контракт или добавить необходимый контекст. Бесшумное подавление исключения скрывает проблему и может оставить состояние некорректным. Для частых ожидаемых ситуаций подходят TryParse, TryGetValue или явный результат операции.
2.63Чем throw отличается от throw ex внутри catch?Средний
Ответ: throw; сохраняет исходную информацию о стеке, а throw ex; начинает её заново с точки повторного выбрасывания. При создании нового исключения исходное можно сохранить в InnerException. Для отложенного перебрасывания вне текущего catch существует ExceptionDispatchInfo.
2.64Для чего нужны фильтры исключений?Средний
Ответ: catch (...) when (...) перехватывает исключение только при выполнении условия. Так можно обрабатывать лишь известные случаи, пропуская остальные выше. Освобождение ресурсов всё равно организуют отдельно через using или finally. Обработка исключений.
Асинхронность: от async/await к управлению операциями
2.65Как работает async/await?Базовый
Ответ: Компилятор преобразует async-метод в машину состояний, сохраняющую данные между продолжениями. Метод выполняется синхронно до первого ожидания незавершённой операции; затем возвращает управление вызывающему коду. await не блокирует поток на время ожидания. Само слово async не создаёт поток, поэтому тяжёлый цикл до первого ожидания может блокировать UI. Механизм async.
2.66Что представляет собой Task?Базовый
Ответ: Task представляет завершение операции, её ошибку или отмену; Task<T> также предоставляет результат типа T. У задачи не обязательно есть выделенный поток: например, ожидание сетевого ответа может обходиться без занятого ожидающего потока. Готовую задачу можно ожидать без асинхронной приостановки.
2.67Чем Thread отличается от ThreadPool?Базовый
Ответ: Thread представляет поток исполнения. ThreadPool управляет набором переиспользуемых потоков, которым выдаются работы и продолжения. Создавать отдельный поток на каждый небольшой запрос обычно дорого; пул уменьшает эти накладные расходы, но его потоки также можно занять блокирующими ожиданиями.
2.68Когда нужен Task.Run?Средний
Ответ: Task.Run отправляет работу в пул потоков. Он полезен, например, для выноса CPU-вычислений из UI-потока. Для I/O предпочтительны асинхронный API и await; обёртка уже асинхронного HTTP-вызова в Task.Run обычно избыточна. На сервере перенос вычисления между потоками пула сам по себе не увеличивает доступную мощность CPU. I/O и CPU.
2.69Достаточно ли Task.Run для надёжной фоновой обработки?Средний
Ответ: Нет: запуск задачи сам по себе не обеспечивает обработку ошибок, корректное завершение приложения и сохранность работы при перезапуске. Нужен управляемый жизненный цикл фоновой работы. Если задание должно переживать остановку процесса, требуется устойчивое хранение задания, например очередь с подходящими гарантиями.
2.70Для чего нужен Task.WhenAll?Средний
Ответ: Он создаёт задачу, завершающуюся после всех переданных задач. Если сначала вызвать несколько асинхронных операций, они могут выполняться конкурентно; последовательные await LoadA(); await LoadB(); запускают вторую только после первой. Сам WhenAll не запускает операции, не выделяет каждой поток и не ограничивает их количество.
2.71Как Task.WhenAll обрабатывает ошибки?Сложный
Ответ: Он дожидается всех задач; ошибка одной не отменяет остальные автоматически. При наличии ошибок объединённая задача становится faulted, а await распространяет одно исключение. Полный набор доступен через Exception.InnerExceptions объединённой задачи. Если ошибок нет, но хотя бы одна задача отменена, отменяется и объединённая. Контракт WhenAll.
2.72Как ограничить число одновременно выполняемых операций?Средний
Ответ: Используют семафор, ограниченное число работников, канал с ограниченной ёмкостью или Parallel.ForEachAsync с заданным пределом параллелизма. Ограничение выбирают с учётом CPU и возможностей внешних систем. Семафор внутри миллиона заранее созданных задач ограничит активные операции, но не устранит расход памяти на сами задачи.
Контекст выполнения и блокирующие ожидания
2.73Что определяет место выполнения продолжения после await?Средний
Ответ: При ожидании Task обычно учитывается текущий SynchronizationContext, а при его отсутствии — нестандартный TaskScheduler. UI-контекст позволяет вернуться на UI-поток. У ASP.NET Core собственного контекста синхронизации запроса по умолчанию нет. Если задача уже завершена, выполнение может продолжиться сразу без переключения потока.
2.74Для чего нужен ConfigureAwait(false)?Сложный
Ответ: Он сообщает, что для этого ожидания возвращение в захваченный контекст синхронизации или планировщик не требуется. Это полезно в библиотечном коде, которому не нужен контекст вызывающего приложения. Он не гарантирует переключения потока и не делает синхронно блокирующий код асинхронным. ConfigureAwait FAQ.
2.75Влияет ли ConfigureAwait(false) на AsyncLocal<T>?Сложный
Ответ: Сам по себе не отключает передачу значений AsyncLocal<T>. Они распространяются через ExecutionContext, который отличается от SynchronizationContext. Поэтому отказ от возвращения в UI-контекст не означает потерю логического контекста асинхронной операции.
2.76Чем опасно синхронное ожидание задачи?Средний
Ответ: .Result, .Wait() и .GetAwaiter().GetResult() могут блокировать поток. В UI возможен deadlock, если продолжение ожидаемой операции требует того же занятого UI-контекста. В ASP.NET Core массовые блокировки могут истощить пул потоков. .GetAwaiter().GetResult() передаёт исходное исключение вместо AggregateException, характерного для .Result/.Wait(), но не устраняет блокировку.
2.77Что такое ThreadPool starvation?Сложный
Ответ: Это ситуация, когда работе не хватает доступных потоков пула, например из-за множества блокирующих ожиданий. Растут очереди и задержки, хотя CPU может быть загружен не полностью. Проверяют метрики пула и стеки потоков. Увеличение минимального числа потоков иногда смягчает симптомы; основную причину устраняют, убирая ненужные блокировки. Диагностика starvation.
2.78Почему следует избегать async void?Средний
Ответ: Его нельзя ожидать, а try/catch вокруг вызова не обеспечивает обработку ошибок тела. Исключения направляются в контекст синхронизации или механизм необработанных исключений и могут завершить процесс. Основное применение — обработчики событий с сигнатурой void. У List<T>.ForEach(async x => ...) тоже получается async void: для ожидаемой последовательной обработки нужен foreach с await. Возвращаемые типы async.
Отмена, асинхронные результаты и время жизни
2.79Как работает CancellationToken?Средний
Ответ: Отмена кооперативна: CancellationTokenSource сообщает о запросе отмены, а операция проверяет токен или передаёт его поддерживающему API. Cancel() не прерывает произвольный поток и не откатывает совершённые действия. Для объединения отмены клиента и лимита времени используют связанный источник с CancelAfter; источник освобождают после работы. Модель отмены.
2.80Отменяет ли Task.WaitAsync(timeout) исходную операцию?Средний
Ответ: Нет: он ограничивает время ожидания, а исходная операция может продолжаться. Чтобы запросить её остановку, нужно передать ей токен отмены. Даже после запроса отмены операция должна самостоятельно завершиться и освободить ресурсы; поддержка отмены зависит от вызываемого API. Контракт WaitAsync.
2.81Когда полезен ValueTask<T>?Сложный
Ответ: Он может хранить готовый результат либо представлять операцию через Task<T> или IValueTaskSource<T>. Это позволяет уменьшить аллокации в часто вызываемом API, особенно при частом синхронном завершении. Структура крупнее ссылки и сложнее в использовании, поэтому исходный выбор обычно Task<T>, а пользу ValueTask<T> подтверждают измерениями. Устройство ValueTask.
2.82Какие ограничения есть у потребления ValueTask?Сложный
Ответ: Общее правило — ожидать экземпляр один раз и не использовать его конкурентно: внутри может быть переиспользуемый источник. Для нескольких ожиданий или передачи в WhenAll можно один раз вызвать AsTask() и дальше использовать полученный Task. Исходный ValueTask после этого отдельно не потребляют; преобразование может снизить выгоду оптимизации.
2.83Чем IAsyncEnumerable<T> отличается от Task<List<T>>?Средний
Ответ: Task<List<T>> предоставляет готовый список после завершения операции. IAsyncEnumerable<T> позволяет постепенно получать элементы через await foreach, асинхронно ожидая следующий. Это может уменьшить задержку до первого элемента и объём памяти, но источник всё ещё способен буферизовать данные. При выходе из await foreach перечислитель освобождается через DisposeAsync, включая выход по break или исключению.
2.84Как передать отмену асинхронному итератору?Средний
Ответ: Потребитель может использовать WithCancellation(token). Метод-итератор принимает токен с [EnumeratorCancellation] и передаёт его реальным операциям. Передача токена сама по себе не прерывает код, который его не проверяет и не поддерживает отмену. Асинхронные потоки.
2.85Можно ли перечислять данные после освобождения DbContext?Средний
Ответ: Нельзя, если перечисление ещё обращается к БД. Контекст и необходимые ресурсы должны оставаться доступны до фактического завершения чтения; медленный потребитель может удерживать их долго. Уже материализованный результат можно читать после закрытия контекста, если последующий доступ не требует новой загрузки.
2.86Когда нельзя заменить return await на возврат Task?Сложный
Ответ: Когда метод должен удерживать ресурс до завершения операции. При using var reader = ...; return reader.ReadToEndAsync(); ресурс закрывается при возврате задачи, хотя чтение может продолжаться. Ожидание внутри области using сохраняет правильное время жизни:
static async Task<string> ReadTextAsync(string path)
{
using var reader = new StreamReader(path);
return await reader.ReadToEndAsync();
}
Прямой возврат задачи уместен для простого перенаправления вызова без подобных требований. Область действия using.
2.87Поймает ли try/catch ошибку задачи без await?Средний
Ответ: try { return OperationAsync(); } catch { ... } ловит только исключение, выброшенное синхронно при получении задачи. Ошибка её последующего завершения в этот catch не попадёт. Чтобы обработать её здесь, нужно ожидать задачу внутри try, например через return await OperationAsync().
Потокобезопасность и синхронизация
2.88Почему counter++ небезопасен при конкурентном доступе?Базовый
Ответ: Увеличение состоит из чтения, вычисления и записи. Два потока могут прочитать одно исходное значение и записать одинаковый результат, потеряв одно увеличение. Атомарность отдельных чтений и записей int не делает атомарной всю последовательность. Для независимого счётчика подходит Interlocked.Increment(ref counter).
2.89Для чего нужен Interlocked?Средний
Ответ: Он предоставляет атомарные операции над отдельным значением, например Increment, Exchange и условную замену CompareExchange. Но несколько вызовов не образуют одну общую атомарную операцию. Для согласованного изменения нескольких связанных полей нужен общий протокол защиты, обычно lock; все читатели также должны его соблюдать. Операции Interlocked.
2.90Что гарантирует lock?Средний
Ответ: Он обеспечивает взаимное исключение для синхронного участка; при конкуренции поток может блокироваться. Для обычного объекта применяется Monitor, для System.Threading.Lock в C# 13+ предусмотрена специальная поддержка компилятора. Используют отдельный приватный объект блокировки, чтобы внешнему коду было сложнее вмешаться в протокол. await внутри lock запрещён. Семантика lock.
2.91Для чего нужен SemaphoreSlim?Средний
Ответ: Он ограничивает число одновременно допущенных операций. WaitAsync позволяет дождаться допуска без блокирования ожидающего потока; SemaphoreSlim(1, 1) подходит для асинхронного взаимного исключения. В отличие от обычного lock, такой семафор не реентерабелен: повторное ожидание из уже защищённого участка может зависнуть. SemaphoreSlim.
2.92Как правильно освобождать допуск SemaphoreSlim?Средний
Ответ: Допуск освобождают в finally, но только после успешного ожидания. Поэтому WaitAsync располагают перед соответствующим try: если ожидание отменится, вызывать Release нельзя. Все операции, защищающие один ресурс, должны использовать один общий экземпляр семафора.
await gate.WaitAsync(cancellationToken);
try
{
await UpdateResourceAsync(cancellationToken);
}
finally
{
gate.Release();
}2.93Что гарантирует volatile?Сложный
Ответ: Он ограничивает переупорядочивание операций памяти: чтение имеет acquire-семантику, запись — release-семантику. Он не обеспечивает взаимное исключение или единый глобальный порядок всех обращений и не делает counter++ атомарным. Описание «всегда немедленно читает последнее значение из RAM» некорректно; для счётчиков обычно нужен Interlocked, для связанных изменений — lock. Гарантии volatile.
2.94Делает ли volatile-ссылка объект потокобезопасным?Средний
Ответ: Нет. В volatile List<T> items правила относятся к чтению и записи ссылки в поле, а не к изменению списка. Одновременные операции с объектом требуют собственной синхронизации или подходящего типа коллекции. Это различие между безопасной передачей ссылки и безопасным использованием доступного через неё состояния.
2.95Какие гарантии даёт ConcurrentDictionary?Средний
Ответ: Он координирует поддерживаемые операции над своей структурой, но не делает атомарной произвольную цепочку вызовов. Для условных изменений существуют TryAdd и TryUpdate. Словарь также не защищает изменяемое состояние объектов, которые хранятся в качестве значений: для него нужен отдельный протокол.
2.96Гарантирует ли GetOrAdd единственный вызов фабрики?Сложный
Ответ: Нет. Пользовательская фабрика вызывается вне внутренних блокировок; несколько потоков могут одновременно вычислить значение одного ключа. Вызов может вернуть значение, созданное другим потоком. Поэтому фабрика не должна полагаться на выполнение ровно один раз, особенно если у неё есть внешние побочные эффекты. Контракт GetOrAdd.
2.97Как Lazy<T> помогает избежать повторного вычисления в GetOrAdd?Сложный
Ответ: В словаре можно хранить Lazy<T> с режимом ExecutionAndPublication, а Value читать у экземпляра, который вернул словарь. Тогда конкурирующие обращения к одному сохранённому Lazy<T> используют его единственную инициализацию. Отдельно определяют обработку ошибок и удаление ключей: это не гарантия единственного вычисления за всю жизнь приложения. Режимы Lazy<T>.
Span, Memory и владение буферами
2.98Для чего нужен Span<T>?Средний
Ответ: Он представляет непрерывный участок памяти и позволяет обрабатывать его или получать срез без копирования элементов. Источником может быть массив, stackalloc или подходящая unmanaged-память. Span<T> — ref struct, предназначенный для непосредственной обработки с ограниченным временем жизни.
2.99Чем Memory<T> отличается от Span<T>?Средний
Ответ: Memory<T> — обычная структура: её можно хранить в объекте и передавать через асинхронные границы. Для непосредственной обработки получают .Span. Само представление не означает владения памятью; при явном владении нужен отдельный контракт, например IMemoryOwner<T>. Span и Memory.
2.100Делают ли ReadOnlySpan<T> и ReadOnlyMemory<T> данные неизменяемыми?Средний
Ответ: Они ограничивают запись через данное представление, но не гарантируют, что исходный буфер не изменит другой владелец ссылки. Для строки типичный вариант — ReadOnlySpan<char>. Доступность только для чтения и глубокая неизменяемость — разные свойства.
2.101Почему у Span<T> есть ограничения времени жизни?Сложный
Ответ: Он может ссылаться на стековую память. Компилятор предотвращает выход такого представления за допустимое время жизни: нельзя вернуть span на локальный stackalloc, упаковать span в object, захватить его в замыкании или сохранить в обычном классе. Span на созданный в методе managed-массив вернуть можно: он поддерживает доступность массива.
2.102Можно ли использовать Span<T> внутри async-метода?Сложный
Ответ: Начиная с C# 13 локальный ref struct допустим в подходящем синхронном участке async-метода. Его нельзя сохранять как состояние через границу await. Для передачи буфера между асинхронными этапами используют Memory<T>, получая span на время синхронной обработки. Ограничения ref struct.
2.103Может ли маленький срез удерживать большой массив?Сложный
Ответ: Да. Представление участка продолжает ссылаться на исходное хранилище. Если нужен только маленький фрагмент надолго, его отдельная копия иногда позволяет освободить большой массив и уменьшить удерживаемую память. Отсутствие копирования не всегда означает меньший расход памяти.
2.104Для чего нужен ArrayPool<T>?Средний
Ответ: Пул переиспользует массивы и может снизить число аллокаций и нагрузку на GC. Rent(minimumLength) возвращает массив не меньше нужной длины, возможно большего размера; его содержимое нельзя считать нулевым. Сам пул удерживает память и требует дисциплины владения, поэтому выгоду подтверждают измерениями.
2.105Когда арендованный массив можно вернуть в пул?Сложный
Ответ: После завершения всех операций, которые используют массив или созданные из него Span/Memory. Массив возвращают тому же пулу ровно один раз, обычно в finally. После Return доступ недопустим: буфер уже может использовать другой потребитель, даже если у первого сохранилась ссылка.
2.106Как очищать чувствительные данные в арендованном массиве?Сложный
Ответ: Return(..., clearArray: true) очищает массив, если пул сохраняет его для повторного использования. Если нужно очистить буфер независимо от решения пула, явную очистку выполняют до возврата. Не следует считать содержимое повторно арендованного массива заведомо пустым. Контракт ArrayPool.Return.
ASP.NET Core
10 вопросов
Конвейер обработки запроса
3.1Что такое middleware?Базовый
Ответ: Это компонент конвейера HTTP-запроса. Он может выполнить действия до и после следующего компонента либо завершить обработку самостоятельно. Компоненты вызываются в порядке регистрации, а код после await next(...) выполняется при возврате по конвейеру в обратном порядке.
3.2Почему важен порядок middleware?Средний
Ответ: Компонент может использовать результат работы предыдущего. Типичная последовательность для API: обработка ошибок → routing → CORS, если нужен → authentication → authorization → endpoint. Routing выбирает endpoint, authentication устанавливает пользователя, authorization проверяет доступ. Часть компонентов WebApplication может добавлять автоматически. Middleware.
3.3Чем middleware отличается от MVC-фильтра?Средний
Ответ: Middleware работает на уровне HTTP-конвейера. MVC-фильтры выполняются внутри обработки MVC-запроса и имеют доступ к соответствующему контексту: action, аргументам или результату. Поэтому общая обработка HTTP-запросов обычно относится к middleware, а логика, зависящая от этапа MVC, может относиться к фильтрам. Фильтры MVC.
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.
3.7Что такое авторизация на уровне ресурса?Средний
Ответ: Это проверка права пользователя на конкретный объект, например заказ своей организации. [Authorize] проверяет требования endpoint, но сам по себе такую проверку не обеспечивает. Используют авторизацию загруженного ресурса либо выборку, ограниченную разрешёнными данными. Проверка только на фронтенде API не защищает. Авторизация ресурса.
Время жизни зависимостей
3.8Чем отличаются Transient, Scoped и Singleton?Базовый
Ответ: Transient создаётся при каждом разрешении зависимости. Scoped — один экземпляр на scope, в обычном HTTP-запросе ASP.NET Core это scope запроса. Singleton — один экземпляр на соответствующую регистрацию в контейнере, обычно на время жизни приложения. Контейнер не делает состояние singleton автоматически потокобезопасным. DI и lifetime.
3.9Почему нельзя напрямую внедрять scoped DbContext в singleton?Средний
Ответ: Singleton захватит зависимость с более коротким временем жизни — это captive dependency. Проверка scope может обнаружить ошибку; без неё контекст может жить слишком долго и использоваться конкурентно. Для фоновой операции создают отдельный scope через IServiceScopeFactory либо контекст через IDbContextFactory<TContext>, освобождая его после завершения работы.
3.10Как получить scoped-сервис в обычном middleware?Средний
Ответ: В обычном middleware, создаваемом при запуске приложения, scoped-зависимость получают параметром InvokeAsync, чтобы использовать scope текущего запроса. Другой вариант — middleware на основе IMiddleware, создаваемый фабрикой с подходящим временем жизни.
SQL
18 вопросов
Соединения, NULL и агрегаты
4.1Чем INNER JOIN отличается от LEFT JOIN?Базовый
Ответ: INNER JOIN возвращает сочетания строк, удовлетворяющие условию соединения. LEFT JOIN дополнительно сохраняет строки левой таблицы без совпадений, заполняя поля правой стороны значением NULL. Если справа несколько совпадений, одна левая строка попадает в несколько строк результата; это важно при расчёте агрегатов.
4.2Что означает NULL?Базовый
Ответ: NULL обозначает отсутствие известного значения. Для проверки используют IS NULL, а не = NULL: обычное сравнение с NULL даёт UNKNOWN. WHERE пропускает только строки, для которых условие истинно, поэтому строки с результатом UNKNOWN отбрасываются. NULL и трёхзначная логика.
4.3Чем COUNT(*) отличается от COUNT(column)?Базовый
Ответ: COUNT(*) считает строки результата. COUNT(column) считает только значения столбца, отличные от NULL; числовой ноль при этом учитывается. После LEFT JOIN это различие позволяет отличить строку клиента без заказа от действительно найденного заказа.
4.4Чем WHERE отличается от HAVING?Базовый
Ответ: WHERE логически отбирает строки до группировки. HAVING фильтрует группы по условиям, например HAVING COUNT(*) > 3. Это логический порядок обработки; физический план выполнения СУБД может организовать иначе. Обработка SELECT.
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.
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.
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 |
Ответ:
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.
Entity Framework Core
15 вопросов
Контекст и отслеживание изменений
5.1Для чего нужен DbContext?Базовый
Ответ: DbContext представляет сессию работы с БД: позволяет выполнять запросы, отслеживать состояние сущностей и сохранять изменения. Обычно его время жизни соответствует одной единице работы. Контекст не предназначен для бессрочного хранения всего загруженного графа объектов.
5.2Можно ли параллельно использовать один DbContext?Средний
Ответ: Нет: DbContext не потокобезопасен и не допускает несколько одновременно выполняющихся операций. Два запроса через Task.WhenAll на одном контексте некорректны даже без явного создания потоков. Нужно дождаться завершения операции либо использовать независимые контексты. Использование DbContext.
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.
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, чем загружать полный граф; при необходимости связанных сущностей используют подходящую предварительную загрузку. Эффективные запросы.
5.9Почему несколько Include могут сделать запрос тяжёлым?Средний
Ответ: При загрузке нескольких коллекций одного уровня сочетания их элементов размножают строки результата. Например, 10 заказов и 5 адресов одного клиента могут дать 50 сочетаний с повторением данных. Поэтому добавление Include не является универсальным исправлением любого медленного запроса.
5.10Для чего нужен AsSplitQuery?Средний
Ответ: Он позволяет загружать коллекции отдельными запросами и уменьшать размножение строк при соединениях. Цена — дополнительные обращения к БД и возможность прочитать части графа из разных состояний данных. Выбор между проекцией, единым запросом и split query проверяют измерениями. Single и split queries.
5.11Гарантирует ли AsSplitQuery согласованный снимок всего графа?Сложный
Ответ: Нет. Между отдельными запросами другая транзакция может изменить данные. Если требуется согласованность чтения всего графа, нужна подходящая транзакция, например snapshot или serializable с учётом конкретной СУБД и стоимости выбранного уровня изоляции.
Сохранение и конкурентные изменения
5.12Что гарантирует один вызов SaveChanges?Средний
Ответ: При стандартных настройках и поддержке транзакций провайдером изменения одного вызова применяются атомарно. Несколько последовательных SaveChanges сами по себе не образуют общую транзакцию. Если нужна общая атомарность, транзакцию задают явно и согласуют с используемой стратегией повторов. Транзакции EF Core.
5.13Как EF Core обнаруживает конкурентное изменение строки?Сложный
Ответ: Настраивается concurrency token. EF добавляет его исходное значение в условие UPDATE или DELETE вместе с ключом. Если ожидаемая строка не обновилась, возникает DbUpdateConcurrencyException: данные могли быть изменены или удалены другой операцией. Без настроенного контроля версии обычный SaveChanges не гарантирует обнаружение потерянного обновления.
5.14Что такое rowversion в SQL Server?Средний
Ответ: Это обновляемый базой маркер версии строки, удобный как concurrency token. Он не является датой или временем. В других СУБД механизм может отличаться; при необходимости токеном версии управляет приложение. Оптимистическая конкуренция EF Core.
5.15Как обрабатывать DbUpdateConcurrencyException?Сложный
Ответ: Перечитать актуальные данные, определить, как объединить либо отклонить изменения, обновить исходный token и при необходимости повторить бизнес-операцию. Слепой повтор SaveChanges не разрешает конфликт. Повтор временного сетевого сбоя — отдельная задача; транзакция БД также не откатывает уже отправленный email или внешний HTTP-вызов.