# Вопросы на собеседовании по C#

301 вопрос с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/csharp

## Платформа .NET и среда выполнения

### Что такое .Net Core?

.NET Core — прежнее название современной кроссплатформенной реализации .NET с открытым исходным кодом: версии 1.0–3.1 назывались .NET Core, начиная с 5.0 слово «Core» убрали, и сегодня платформа называется просто «.NET» (актуальная LTS — .NET 10).

Источник: https://learn.microsoft.com/dotnet/core/introduction

### Разница между .NetCore и .NetFramework?

Главная разница: .NET Framework работает только в Windows и ставится в систему как её компонент, а современный .NET (бывший .NET Core) кроссплатформенный, с открытым исходным кодом и развивается дальше.

Источник: https://learn.microsoft.com/dotnet/standard/choosing-core-framework-server

### Что такое .NET Standard?

.NET Standard — формальная спецификация набора API, которые должны быть доступны во всех реализациях .NET (.NET Framework, .NET Core и 5+, Mono, Xamarin); её ввели, чтобы одну библиотеку классов можно было использовать на разных реализациях.

Источник: https://learn.microsoft.com/dotnet/standard/net-standard

### Что такое CLR?

CLR (Common Language Runtime) — среда выполнения .NET: она исполняет управляемый код и предоставляет ему сервисы.

Источник: https://learn.microsoft.com/dotnet/standard/clr

### Что такое MSIL (CIL)

MSIL (Microsoft Intermediate Language), он же CIL (Common Intermediate Language) или просто IL — не зависящий от процессора набор инструкций, в который компилируется любой язык .NET.

Источник: https://learn.microsoft.com/dotnet/standard/managed-execution-process

## ООП

### Каковы основные возможности ООП?

Основные возможности ООП — инкапсуляция, наследование и полиморфизм; документация C# называет их тремя главными характеристиками, а в учебных материалах к ним добавляют абстракцию.

Источник: https://learn.microsoft.com/dotnet/csharp/fundamentals/tutorials/oop

### Какие существуют методы у класса Object?

У `System.Object` восемь методов: `Equals(object)`, статический `Equals(object, object)`, `ReferenceEquals(object, object)`, `GetHashCode()`, `GetType()`, `ToString()`, а также защищённые `MemberwiseClone()` и `Finalize()`.

Источник: https://learn.microsoft.com/dotnet/api/system.object

### Что такое базовый класс (base class) и производный класс (derived class)?

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

Источник: https://learn.microsoft.com/dotnet/csharp/fundamentals/object-oriented/inheritance

### Есть ли у нас множественное наследование в .NET?

Нет: у класса в .NET один прямой базовый класс, множественного наследования классов нет, но класс может реализовать сколько угодно интерфейсов.

Источник: https://learn.microsoft.com/dotnet/csharp/fundamentals/types/interfaces

### Что вызывается первым — конструктор базового класса или производного?

Тело конструктора базового класса выполняется раньше тела конструктора производного, но самыми первыми выполняются инициализаторы полей производного класса.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/language-specification/classes

## Типы данных и коллекции

### Разница между StringBuilder и string?

`string` неизменяем, `StringBuilder` изменяем. Любая операция над строкой, которая выглядит как изменение, создаёт новый объект. `StringBuilder` держит изменяемый буфер символов и меняет его на месте, а итоговую строку вы получаете вызовом `ToString()`. Поэтому сборка текста из заранее неизвестного числа кусков в цикле через `string` копирует накопленный текст на каждой итерации, а через `StringBuilder` дописывает его в буфер.

Источник: https://learn.microsoft.com/dotnet/api/system.text.stringbuilder

### Сотни тысяч строк нужно собрать в одну. Что взять вместо оператора `+` в цикле, если строки уже лежат в списке и если они появляются по ходу работы?

Выбор зависит от того, есть ли все куски заранее. Если строки уже в коллекции, их объединяют одним вызовом: `string.Concat(parts)` без разделителя или `string.Join(", ", parts)`, когда нужен разделитель. Если куски появляются по ходу работы и их число неизвестно заранее, берут `StringBuilder`: он собирает результат в одном буфере, а `ToString()` вызывают в конце. Цикл с `+=` здесь хуже обоих вариантов: строки неизменяемы, и каждая операция создаёт новую строку, так что на сотнях тысяч шагов выделения складываются.

Источник: https://learn.microsoft.com/dotnet/csharp/how-to/concatenate-multiple-strings

### Как устроен StringBuilder внутри?

В .NET 10 `StringBuilder` хранит текст как цепочку блоков символов, а не как один массив, который переписывается при росте. Когда текущий блок заполнен, билдер выделяет новый блок и связывает с ним прежний как предыдущий. Старые символы при этом не копируются. Размер нового блока не меньше запрошенного и стремится к текущей длине, то есть ёмкость примерно удваивается, но шаг роста ограничен 8000 символами, чтобы новые массивы не попадали в кучу больших объектов. Итоговую строку `ToString()` выделяет один раз и собирает из блоков копированием.

Источник: https://github.com/dotnet/runtime/blob/release/10.0/src/libraries/System.Private.CoreLib/src/System/Text/StringBuilder.cs

### Что такое интернирование строк?

Интернирование хранит один экземпляр на каждое уникальное значение строки в таблице CLR (intern pool), и равные строки из неё указывают на один объект. Строковые литералы программы обычно попадают в пул сами. Строки, построенные во время выполнения (конкатенация переменных, `StringBuilder.ToString()`, `string.Format`), не попадают, пока вы не вызовете `string.Intern(s)`: она вернёт ссылку из пула и добавит строку, если её там не было. `string.IsInterned(s)` только проверяет наличие и ничего не добавляет.

Источник: https://learn.microsoft.com/dotnet/api/system.string.intern

### Как под капотом происходит сравнение строк и как реализована оптимизация?

`==` и `string.Equals` сравнивают значения строк посимвольно, порядково (ordinal) и с учётом регистра, а не ссылки. Ссылки проверяются только как быстрый выход. В исходниках .NET 10 `String.Equals(a, b)` работает так: если ссылки совпали, возвращает `true`; если одна из строк `null` или длины разные, возвращает `false`; иначе сравнивает содержимое одним вызовом сравнения блоков памяти (`SpanHelpers.SequenceEqual`). Проверки ссылок и длин идут до чтения символов, а интернирование ускоряет только случай совпавших ссылок.

Источник: https://github.com/dotnet/runtime/blob/release/10.0/src/libraries/System.Private.CoreLib/src/System/String.Comparison.cs

### Каковы некоторые рекомендации по выбору между decimal, float и double?

Деньги и другие значения с заданным числом десятичных знаков считают в `decimal`, измерения и научные расчёты в `double`, а `float` берут, когда важна память. `decimal` хранит число в десятичном виде, поэтому 0.1 представляется в нём точно, а ни в `double`, ни в `float` точного 0.1 нет, и арифметика над денежными суммами накапливает ошибки округления. У `decimal` 28-29 значащих цифр и 16 байт на значение; у `double` примерно 15-17 цифр и 8 байт, у `float` примерно 6-9 цифр и 4 байта, но их диапазон значительно шире.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/builtin-types/floating-point-numeric-types

### При итерации по двумерному массиву (int[,]) в C#, какой порядок обхода (по строкам или по столбцам) будет быстрее и почему?

Правильный порядок: по строкам, с внешним циклом по первому индексу и внутренним по второму. Элементы `int[,]` лежат в одном блоке в порядке строк: рядом в памяти находятся элементы, у которых различается последний индекс. В исходниках .NET 10 плоский индекс считается как `flattenedIndex = length * flattenedIndex + index` по измерениям слева направо, поэтому последний индекс меняется в памяти быстрее всех. Перебор по строкам читает память подряд, перебор по столбцам перепрыгивает через целую строку на каждом шаге, то есть идёт с шагом в длину строки.

Источник: https://github.com/dotnet/runtime/blob/release/10.0/src/libraries/System.Private.CoreLib/src/System/Array.cs

## LINQ

### Есть `var numbers = new List<int> { 1, 2, 3, 4 };` и запрос `var evens = numbers.Where(n => n % 2 == 0);`. После объявления запроса в список добавляют число 6, и только затем запускают `foreach (var n in evens)`. Какие числа выведет цикл и когда список читался на самом деле?

Цикл выведет 2, 4 и 6: список читается в момент перебора, а не в момент объявления запроса. `Where` ничего не фильтрует при вызове. Он возвращает объект, который хранит источник и предикат, а работа начинается при перечислении (`foreach`, `ToList`, `Count`). Результат поэтому зависит от содержимого источника на момент выполнения, и число 6, добавленное после объявления, в него попадает. Если перечислить тот же запрос второй раз, источник будет прочитан заново, и результаты могут отличаться.

Источник: https://learn.microsoft.com/dotnet/csharp/linq/get-started/introduction-to-linq-queries

### Метод возвращает `IEnumerable<Order>`, построенный как `ordersFromDb.Where(o => o.Total > 100)`, где `ordersFromDb` при каждом переборе обращается к базе. Вызывающий код пишет `if (result.Count() > 0)`, а затем `foreach (var o in result)`. Сколько раз выполнится запрос и как это исправить?

Запрос выполнится дважды: `Count()` перебирает последовательность целиком, а `foreach` запускает её с начала. `IEnumerable<T>`, полученный из отложенного оператора, хранит рецепт, а не результат, и каждый перебор идёт заново от источника. Если источник дорогой (база, файл, сеть) или меняется между прочтениями, вы платите дважды и можете получить два разных набора: документация прямо предупреждает, что при повторном переборе результаты могут отличаться.

Источник: https://learn.microsoft.com/dotnet/csharp/linq/get-started/introduction-to-linq-queries

### Для `var q = items.Select(x => { Log(x); return x * 2; });` вызывают `Console.WriteLine("готово");`, а затем `var first = q.First();`. В `items` пять элементов. В каком порядке произойдут вывод строки и вызовы `Log`, и сколько раз вызовется `Log`?

Сначала выведется «готово», затем `Log` вызовется один раз, для первого элемента. `Select` отложенный и потоковый: при объявлении запроса ничего не выполняется, а при переборе он берёт из источника столько элементов, сколько нужно для очередного результата. `First()` выполняется сразу и запрашивает у последовательности один элемент, поэтому остальные четыре элемента не проходят через лямбду.

Источник: https://learn.microsoft.com/dotnet/csharp/linq/get-started/introduction-to-linq-queries

## Обработка исключений

### Как реализовать обработку исключений?

Исключения обрабатывают оператором `try` с блоками `catch` и `finally`, а выбрасывают оператором `throw`: в `try` лежит код, который может бросить исключение, `catch` перехватывает подходящее, `finally` выполняется при любом выходе из `try`.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/statements/exception-handling-statements

### В блоке try-catch-finally, возможно ли одновременное срабатывание нескольких catch-блоков?

Нет: для одного брошенного исключения выполняется не больше одного `catch`-блока, первый подходящий сверху вниз; `finally` после него выполняется в любом случае.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/statements/exception-handling-statements

### В чем заключается разница между throw; и throw ex; при повторном выбрасывании исключения?

`throw;` повторно выбрасывает текущее исключение и сохраняет его исходный стек вызовов, а `throw ex;` начинает трассировку стека заново с места этого `throw`, поэтому исходная точка ошибки теряется.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/statements/exception-handling-statements

## Делегаты и лямбда-выражения

### Объясните концепцию делегатов. Как они используются?

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

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/

### Что такое Func, Action и Predicate?

Это готовые обобщённые типы делегатов. `Func<..., TResult>` описывает метод с результатом (последний параметр типа — тип результата), `Action<...>` метод без результата, `Predicate<T>` метод с одним параметром, возвращающий `bool`. Для `Func` и `Action` предусмотрено до 16 входных параметров. Лямбда преобразуется в любой из них:

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions

### Что такое ковариация и контравариантность? Как они применяются к делегатам, дженерикам или интерфейсам?

Ковариантность разрешает подставить более производный тип там, где ожидается базовый, и действует для параметров типа, которые только отдают значения (`out`). `IEnumerable<string>` присваивается `IEnumerable<object>`, `Func<string>` присваивается `Func<object>`. Контравариантность работает в обратную сторону для параметров типа, которые только принимают значения (`in`): `Action<object>` присваивается `Action<string>`, `IComparer<object>` годится вместо `IComparer<string>`. У `Func<T, TResult>` параметр `T` контравариантен, `TResult` ковариантен.

Источник: https://learn.microsoft.com/en-us/dotnet/standard/generics/covariance-and-contravariance

## Многопоточность и асинхронность

### Что такое многопоточность и какие средства для неё есть в .NET?

Многопоточность — выполнение нескольких потоков в одном процессе, чтобы разная работа шла одновременно. В .NET для неё три уровня. Task Parallel Library (TPL) и PLINQ — рекомендуемый путь, оба работают на потоках пула. `ThreadPool` — набор рабочих потоков, которым управляет среда выполнения. Класс `Thread` даёт прямой доступ к управляемому потоку, когда нужен отдельный поток со своими настройками (приоритет, фоновый или основной).

Источник: https://learn.microsoft.com/dotnet/standard/threading/threads-and-threading

### Чем асинхронное программирование отличается от синхронного в .NET?

Синхронный вызов держит поток, пока операция не завершится, асинхронный возвращает управление сразу, а остаток кода выполняется после завершения операции. Для операций ввода-вывода (сеть, диск, база) это означает, что пока операция ждёт, поток свободен и может делать другую работу: интерфейс остаётся отзывчивым, а сервер обслуживает больше запросов тем же числом потоков. В C# асинхронный код пишут через `async`/`await` и `Task`: `await` не блокирует поток, а регистрирует продолжение.

Источник: https://learn.microsoft.com/dotnet/csharp/asynchronous-programming/async-scenarios

### Чем параллельное программирование отличается от асинхронного?

Параллельное выполнение использует несколько потоков и процессоров одновременно, чтобы ускорить вычисления; асинхронность освобождает поток, пока операция чего-то ждёт, и сама новых потоков не создаёт. Документация делит работу на два вида. Для I/O-bound кода (нужно дождаться данных) применяют `async`/`await` без `Task.Run`. Для CPU-bound кода (дорогое вычисление) используют `await Task.Run(...)`, а если работу можно разделить на части, то параллельные средства Task Parallel Library: `Parallel.For`/`Parallel.ForEach` и PLINQ.

Источник: https://learn.microsoft.com/dotnet/csharp/asynchronous-programming/async-scenarios

### Чем `Task` отличается от `Thread` и что выбрать для обычной фоновой работы?

Для обычной фоновой работы выбирают `Task`: это единица работы, которую планировщик по умолчанию выполняет на потоках пула, а `Thread` — управляемый поток, которым вы управляете сами. Задачи ставятся в очередь `ThreadPool`, а пул подбирает число потоков под нагрузку, поэтому задач можно создавать много. Для них есть готовые ожидание, продолжения, отмена, обработка исключений и статус. Документация называет TPL предпочтительным API для многопоточного и асинхронного кода.

Источник: https://learn.microsoft.com/dotnet/standard/parallel-programming/task-based-asynchronous-programming

### Чем «зелёные потоки» отличаются от потоков ОС и какое отношение это имеет к задачам в .NET?

Зелёным потоком (корутиной) управляет среда выполнения, а не ядро ОС, поэтому такие потоки дешёвые. Горутины Go — пример: их мультиплексируют на набор потоков ОС, а когда одна блокируется системным вызовом, остальные с того же потока среда переносит на другой, так что программа не встаёт. Стек горутины занимает несколько килобайт, и в одном адресном пространстве практично создавать сотни тысяч горутин.

Источник: https://go.dev/doc/faq

### Какие состояния бывают у управляемого потока (`System.Threading.ThreadState`)?

`ThreadState` — флаговое перечисление, основные значения такие: `Unstarted` (поток создан, `Start()` ещё не вызывали), `Running` (запущен и не остановлен), `WaitSleepJoin` (заблокирован из-за `Sleep`, `Join`, ожидания блокировки через `Monitor.Enter` или `Monitor.Wait`, либо ожидания объекта синхронизации вроде `ManualResetEvent`) и `Stopped` (завершён). Отдельный флаг `Background` показывает, что поток фоновый. Есть и значения запросов приостановки и остановки (`SuspendRequested`, `AbortRequested`), но Abort в современном .NET не поддерживается.

Источник: https://learn.microsoft.com/dotnet/api/system.threading.threadstate

### Зачем нужен `ThreadPool` и когда он не подходит?

`ThreadPool` — набор рабочих потоков, которым управляет среда выполнения: потоки используются повторно, поэтому для каждой короткой операции не нужно создавать и уничтожать свой поток. На пуле работают задачи (`Task`, TPL), завершение асинхронного ввода-вывода, таймеры и сокеты. Размер пула ограничен: когда все потоки заняты, новая работа ждёт в очереди. Поэтому длительная блокирующая работа в пуле вредна: она занимает поток надолго, а очередь стоит.

Источник: https://learn.microsoft.com/dotnet/standard/threading/the-managed-thread-pool

### Для чего нужны ключевые слова `async` и `await`?

Они позволяют писать асинхронный код как последовательный: `await` приостанавливает метод до завершения задачи, не блокируя поток, а остаток метода регистрируется как продолжение. Если задача завершилась с исключением, `await` его пробрасывает. `await` работает с любым типом, у которого есть подходящий `GetAwaiter`, чаще всего с `Task` и `ValueTask`.

Источник: https://learn.microsoft.com/dotnet/csharp/asynchronous-programming/task-asynchronous-programming-model

### Во что компилятор превращает `async`/`await` и что происходит на первом `await`?

В конечный автомат, который генерирует компилятор. Локальные переменные и параметры, которые должны пережить приостановку, становятся полями, ещё одно поле хранит текущую позицию в методе, а код между `await` собран в метод `MoveNext`. Метод выполняется синхронно до первого `await` на незавершённой задаче. Там автомат регистрирует `MoveNext` как продолжение и возвращает вызывающему задачу; когда ожидаемая задача завершится, `MoveNext` вызывается снова и идёт с сохранённого места. Если задача к `await` уже завершена, выполнение идёт дальше в том же вызове `MoveNext`.

Источник: https://devblogs.microsoft.com/dotnet/how-async-await-really-works/

### Что делает `Task.Run` и когда его применять?

`Task.Run` ставит делегат в очередь пула потоков и возвращает задачу для этой работы. Применяют его для вычислений на процессоре, которые не должны занимать текущий поток, например UI-поток: `await Task.Run(() => HeavyCompute())`. Для ввода-вывода (сеть, диск, база) `Task.Run` не нужен: у таких операций есть асинхронные API, а `await` на них поток не занимает. Обёртка в `Task.Run` заняла бы поток пула на всё время ожидания.

Источник: https://learn.microsoft.com/dotnet/api/system.threading.tasks.task.run

### Чем `Task<T>` отличается от `ValueTask<T>` и когда `ValueTask<T>` оправдан?

`Task<T>` — ссылочный тип, и на каждый вызов создаётся объект в куче. `ValueTask<T>` — структура, которая оборачивает готовый результат, `Task<T>` или `IValueTaskSource<T>`, поэтому при синхронном завершении выделения памяти нет. Оправдан он для метода, который часто завершается синхронно (например, берёт значение из кэша) и вызывается так часто, что выделение `Task` заметно. Документация требует брать `Task` по умолчанию, а `ValueTask` только после замера.

Источник: https://learn.microsoft.com/dotnet/api/system.threading.tasks.valuetask-1

### Почему `async void` не рекомендуют и в каком случае он нужен?

`async void` оставляют только для обработчиков событий, где сигнатура требует `void`; во всех остальных методах возвращайте `Task`. У такого метода нет задачи, поэтому вызывающий не может ни дождаться завершения, ни поймать исключение. Исключение уходит в `SynchronizationContext`, который был активен при старте метода, и необработанным, скорее всего, обрушит приложение. Такой метод нельзя передать в `Task.WhenAll`, и его трудно тестировать: ждать нечего.

Источник: https://learn.microsoft.com/dotnet/standard/asynchronous-programming-patterns/common-async-bugs

### Что произойдёт, если в `async`-методе вызвать асинхронный метод без `await` и что об этом скажет компилятор?

Вызывающий метод не дождётся операции: выполнение пойдёт дальше, пока она ещё идёт, а вы получите объект `Task`. Если вызов стоит внутри `async`-метода, компилятор предупреждает об этом (CS4014); в синхронном методе предупреждения нет. Исключение, которое бросит операция, сохраняется в задаче, и если её не ожидать и не проверять, оно теряется. В современном .NET неотслеженное исключение задачи не обрушивает процесс: оно приходит в событие `TaskScheduler.UnobservedTaskException` при финализации задачи, после чего игнорируется, поэтому ошибка остаётся незамеченной.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/compiler-messages/async-await-errors

### Как выполнить асинхронную операцию синхронно и почему это опасно?

Поток блокируют через `.Result`, `.Wait()` или `.GetAwaiter().GetResult()`, но применять это стоит только там, где `await` недоступен, потому что блокировка опасна двумя способами. Первый — взаимоблокировка: на потоке с однопоточным `SynchronizationContext` (UI в WPF и WinForms, классический ASP.NET) продолжение метода пытается вернуться в этот контекст, а его поток занят ожиданием. Второй — расход потоков: блокирующее ожидание занимает поток пула, который мог бы выполнять другую работу, а при высокой нагрузке пулу приходится добавлять потоки.

Источник: https://learn.microsoft.com/dotnet/standard/asynchronous-programming-patterns/common-async-bugs

### Что такое контекст синхронизации (`SynchronizationContext`) и где продолжится метод после `await`?

`SynchronizationContext` определяет, куда вернуть выполнение: `await` запоминает текущий контекст, и если он есть, остаток метода отправляется в него. В WinForms и WPF контекст возвращает продолжение в UI-поток, поэтому после `await` можно обращаться к элементам интерфейса. Если контекста нет, продолжение выполняется там, где завершилась задача, обычно на потоке пула.

Источник: https://devblogs.microsoft.com/dotnet/configureawait-faq/

## Синхронизация потоков

### Поле объявлено как `private readonly Lock _gate = new();`, но в другом методе его передают параметром типа `object` и там пишут `lock (gate)`. Какой механизм блокировки будет использован внутри этого метода и что скажет компилятор?

Внутри метода `lock` пойдёт через `Monitor`, а компилятор предупредит (CS9216) там, где `Lock` приводят к `object`, то есть на передаче параметра, а не внутри метода. Решает статический тип выражения в самом `lock`. Если компилятор видит там тип `System.Threading.Lock` (.NET 9, C# 13), он генерирует `using (x.EnterScope())`; для любого другого ссылочного типа, в том числе `object`, это пара `Monitor.Enter`/`Monitor.Exit` в `try`/`finally`. Объект `Lock`, переданный как `object`, блокируется как обычный объект, и выигрыш `Lock` пропадает.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/statements/lock

### Несколько потоков после каждого запроса увеличивают общий счётчик `int count` и общую сумму `long total`. Хватит ли `Interlocked.Increment(ref count)` и `Interlocked.Add(ref total, x)`, если читатель должен всегда видеть согласованную пару `(count, total)`?

Не хватит. Каждый вызов `Interlocked` атомарен сам по себе, но два вызова — это две отдельные операции, между ними другой поток успеет прочитать новое `count` со старым `total`. Согласованность двух полей обеспечивает общая блокировка (`lock`) вокруг обоих изменений и вокруг чтения.

Источник: https://learn.microsoft.com/dotnet/api/system.threading.interlocked

### Два потока одновременно выполняют `Interlocked.CompareExchange(ref x, 5, 0)`, где `x == 0`. Что вернёт каждый вызов и чему будет равен `x`?

`x` станет равен 5, один вызов вернёт 0, другой вернёт 5. `CompareExchange` атомарно сравнивает значение в `location1` с `comparand` и, если они равны, записывает новое. Возвращает он всегда исходное значение из `location1`, произошла замена или нет. Вызов, выполненный первым, видит 0, записывает 5 и возвращает 0. Второй видит уже 5, замену не делает и возвращает 5. Победитель один, какой именно, решает порядок выполнения.

Источник: https://learn.microsoft.com/dotnet/api/system.threading.interlocked.compareexchange

## GC

### Объясните разницу между value и ссылочным типом?

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

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types

### В чем разница между стеком и кучей?

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

Источник: https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals

### Сколько существует стеков и куч?

Стек у каждого потока свой. Управляемых куч в процессе одна при Workstation GC и несколько при Server GC: на каждый логический процессор своя куча с собственным потоком сборки, и объекты разных куч могут ссылаться друг на друга. Если включена DATAS (по умолчанию с .NET 9), число куч меняется во время работы: она начинает с одной.

Источник: https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals

### Что происходит с данными в стеке, когда stack pointer двигается вверх?

Память кадра метода возвращается: при выходе из метода указатель стека возвращается к предыдущему кадру (в какую сторону по адресам он при этом сдвигается, зависит от платформы), локальные переменные метода перестают существовать, а место используется следующими вызовами. Сборщик мусора в этом не участвует. Спецификация C# называет это так: память локальных переменных автоматически восстанавливается, когда функция завершается.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions

### Всегда ли value types хранятся в stack, и всегда ли reference types — в heap?

Нет, ни в ту, ни в другую сторону. Значимый тип оказывается в куче, когда он поле объекта класса, элемент массива, упакован (boxing копирует значение в новый объект управляемой кучи) или захвачен лямбдой: захваченная локальная переменная становится полем объекта-замыкания. Гарантированно на стеке живут только `ref struct`, например `Span<T>`: поле класса такого типа объявить нельзя.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/boxing-and-unboxing

### Каковы преимущества и ограничения использования структур по сравнению с классами?

Структура выгодна, когда экземпляров много, они небольшие и описывают значение. Переменная структуры содержит сам экземпляр, поэтому элементы массива структур хранят значения, а не ссылки на отдельные объекты, и на каждый элемент не нужно отдельное выделение и отдельный объект для сборщика. Документация советует делать структуры небольшими, ориентированными на данные и неизменяемыми (`readonly struct`).

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct

### Как работает сборка мусора в NET?

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

Источник: https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals

### Как GC помечает объекты на удаление?

Помечаются живые объекты, а не удаляемые. Сборщик строит граф достижимости от корней (статические поля, локальные переменные в стеках потоков, регистры, GC-дескрипторы, очередь финализации), всё достигнутое отмечает живым, а недостижимое считает мусором. Счётчика ссылок нет, поэтому цикл A ↔ B, до которого нет пути от корней, будет собран. Это фаза маркировки.

Источник: https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals

### Может ли GC удалить циклически ссылающиеся объекты (A ссылается на B, B на A), если на них нет ссылок от корней?

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

Источник: https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals

## Неуправляемые ресурсы

### Какие есть механизмы для очистки неуправляемых ресурсов?

Основной механизм — шаблон освобождения на базе `IDisposable` (детерминированная очистка через `Dispose`), а страховку на случай, если `Dispose` забыли вызвать, дают безопасный дескриптор (`SafeHandle`) или финализатор.

Источник: https://learn.microsoft.com/dotnet/standard/garbage-collection/unmanaged

### Как работает IDisposable?

`IDisposable` с единственным методом `Dispose()` даёт детерминированное освобождение ресурсов: вызывающий код сам решает, когда закрыть дескриптор файла, сокет или подключение, не дожидаясь неопределённого момента работы сборщика мусора.

Источник: https://learn.microsoft.com/dotnet/standard/garbage-collection/implementing-dispose

### Может ли не сработать метод Dispose при использовании конструкции using?

Практически нет: `using` гарантирует вызов `Dispose()` при выходе из блока, в том числе при исключении, потому что компилятор разворачивает его в `try`-`finally`.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/statements/using

## ORM

### Как работает EF? Какие преимущества использования?

EF Core превращает LINQ-запрос к классам модели в SQL и строки результата в объекты. Запрос над `DbSet` строится как дерево выражений, провайдер базы определяет, какие части выполнимы в базе, переводит их в SQL своего диалекта, а результат материализуется в сущности. Отслеживающий запрос регистрирует их в трекере изменений контекста `DbContext`, и `SaveChanges` по накопленным изменениям формирует INSERT, UPDATE и DELETE и выполняет их в одной транзакции.

Источник: https://learn.microsoft.com/en-us/ef/core/querying/how-query-works

### Какие есть подходы работы с EF?

Два основных подхода, они различаются тем, что считается источником истины: Code First (миграции), где источником служит модель в коде, и Database First (обратное проектирование), где источником служит схема базы.

Источник: https://learn.microsoft.com/en-us/ef/core/managing-schemas/

### Что такое Lazy Load и Include в EF?

`Include` — жадная загрузка: связанные сущности приходят в том же запросе, по умолчанию одним SQL с JOIN (с `AsSplitQuery()` отдельными запросами). Ленивая загрузка читает связанные данные отдельным запросом при первом обращении к навигационному свойству.

Источник: https://learn.microsoft.com/en-us/ef/core/querying/related-data/lazy

### Как работать с транзакциями в Entity Framework? Что произойдет с изменениями, если в конце будет вызван метод Rollback?

Явную транзакцию открывают через `await using var tx = await context.Database.BeginTransactionAsync();`, выполняют в ней несколько `SaveChangesAsync()` и запросов и завершают `CommitAsync()`. `Rollback` отменяет всё, что выполнено внутри транзакции, и в базе ничего не остаётся. Если выйти из `using` без `Commit`, откат произойдёт сам.

Источник: https://learn.microsoft.com/en-us/ef/core/saving/transactions

### Что такое ExpressionTree?

Дерево выражений представляет код в виде структуры данных: каждый узел описывает операцию, вызов метода или константу, дерево можно разобрать, на его основе построить изменённое дерево и скомпилировать. Компилятор строит его, когда лямбда присвоена типу `Expression<TDelegate>`: `Expression<Func<int, bool>> f = n => n < 5`. Та же лямбда, присвоенная `Func<int, bool>`, становится обычным делегатом.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/

### Каким образом Entity Framework отслеживает изменения, чтобы понимать, какое конкретно поле сущности было изменено?

Сравнением со снимком. Когда контекст начинает отслеживать сущность, он сохраняет копию значений её свойств. При `SaveChanges` EF вызывает `ChangeTracker.DetectChanges()`, сравнивает текущие значения со снимком и помечает изменившиеся свойства, поэтому в `UPDATE` попадают только они. Тот же вызов делают `ChangeTracker.Entries()` и `HasChanges()`, чтобы состояния сущностей (`Unchanged`, `Modified`, `Added`, `Deleted`) были актуальны.

Источник: https://learn.microsoft.com/en-us/ef/core/change-tracking/change-detection

## DI

### Чем внедрение зависимостей в .NET отличается от создания зависимостей через `new` внутри класса и что оно даёт при замене реализации и тестировании?

При внедрении зависимостей класс объявляет нужные ему зависимости как интерфейсы в конструкторе, а создаёт и освобождает их контейнер. При `new` внутри класса он жёстко привязан к конкретному типу. Следствия описаны в документации: реализацию меняют правкой одной регистрации, а не всех потребителей; настройка зависимостей собрана в одном месте, а не разбросана по приложению; в тесте вместо реального типа подставляют заглушку. Контейнер строит граф: для каждой зависимости он разрешает её собственные зависимости.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/overview

### Сервис зарегистрирован как Transient, Scoped или Singleton. Сколько экземпляров получат два потребителя в одном HTTP-запросе и два потребителя из разных запросов и когда контейнер освободит каждый?

Transient: каждое обращение к контейнеру создаёт новый экземпляр, поэтому два потребителя даже в одном запросе получат разные объекты. Scoped: один экземпляр на область, а в веб-приложении область равна HTTP-запросу; в одном запросе потребители делят объект, в разных запросах получают разные. Singleton: один экземпляр на приложение, он создаётся при первом обращении, общий для всех запросов и поэтому должен быть потокобезопасным. Объекты, которые контейнер создал и которые реализуют `IDisposable`, он освобождает сам: transient и scoped в конце запроса, singleton при остановке приложения.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/service-lifetimes

### Когда контейнер создаёт singleton и кто его освобождает, если экземпляр передан готовым через `AddSingleton(new Service())`?

По умолчанию singleton создаётся при первом обращении к нему, а не при старте приложения. Если зарегистрировать готовый экземпляр (`AddSingleton(new Service())`), объект создаёте вы в момент регистрации. От этого зависит и освобождение: экземпляр, который создал контейнер, он освобождает сам при остановке приложения, а готовый экземпляр контейнер не освобождает, и вызвать `Dispose` придётся вам. Регистрация фабрикой (`AddSingleton<IService>(sp => new Service())`) остаётся под управлением контейнера: объект создаётся при первом обращении и освобождается контейнером.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/service-lifetimes

### Чем область (scope) в фоновой службе (`BackgroundService`) отличается от области в обработчике HTTP-запроса и кто за неё отвечает?

В обработчике запроса область создаёт и закрывает ASP.NET Core: на запрос приходится одна область. У фоновой службы запроса нет, поэтому неявной области нет, и вы создаёте её сами. Для этого в службу внедряют `IServiceScopeFactory` (он зарегистрирован как singleton), а в `ExecuteAsync` на каждую порцию работы вызывают `CreateScope()` внутри `using` и берут scoped-сервисы из `scope.ServiceProvider`. Область, которую вы создали, освобождаете вы: с её закрытием освобождаются созданные в ней scoped-сервисы.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/overview#scope-scenarios

## Общее

### Что такое обобщенные элементы (generics) и почему они полезны?

Обобщения (generics) — классы, структуры, интерфейсы и методы с параметрами типа (`T`, `TKey`), которые пишутся один раз и работают с любым типом, а конкретный тип подставляется при использовании: `List<int>`, `Print<string>(...)`.

Источник: https://learn.microsoft.com/dotnet/csharp/fundamentals/types/generics

### Что происходит с generic методами на уровне компиляции?

Компилятор C# не копирует код под каждый тип: он компилирует обобщение один раз в IL с метаданными о параметрах типа, а специализацию делает CLR при выполнении (в JIT), и для значимых и ссылочных типов по-разному.

Источник: https://learn.microsoft.com/dotnet/csharp/programming-guide/generics/generics-in-the-run-time

### Разница между параметрами in, ref и out?

Все три передают аргумент по ссылке, а различаются обязательствами: `ref` — переменную нужно инициализировать до вызова, метод может читать и менять её; `out` — инициализировать до вызова не нужно, но метод обязан присвоить значение до выхода; `in` — только для чтения, присваивать параметру нельзя.

Источник: https://learn.microsoft.com/dotnet/csharp/language-reference/keywords/method-parameters

## Middleware и фильтры

### Что такое middleware в ASP.NET Core и как из таких компонентов строится конвейер запроса?

Middleware — компонент конвейера: делегат, который решает, передать ли запрос следующему компоненту, и может выполнять работу до и после него. Конвейер собирается из таких делегатов вызовами `Use`, `Run` и `Map`: запрос проходит их по порядку регистрации, ответ возвращается в обратном порядке. Каждый компонент отвечает за вызов следующего или за короткое замыкание конвейера; замыкающий компонент называют терминальным, потому что дальше запрос не идёт.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-10.0

### В чём разница между `Use`, `Run` и `Map` при регистрации middleware и чем `Map` отличается от `UseWhen`?

`Use` добавляет компонент, который получает `next` и может вызвать следующий. `Run` добавляет терминальный компонент без параметра `next`: первый `Run` завершает конвейер, а все `Use` и `Run` после него не вызываются. `Map` ветвит конвейер по началу пути запроса: если путь начинается с заданного, запрос уходит в отдельную ветку, а совпавшие сегменты переносятся из `Path` в `PathBase`. В основной конвейер запрос из ветки `Map` не возвращается. `UseWhen` ветвит по предикату `Func<HttpContext, bool>` и, в отличие от `Map` и `MapWhen`, возвращает ветку в основной конвейер, если она не замыкает его и не содержит терминального middleware.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-10.0

### Конвейер зарегистрирован по порядку: собственное логирование (`app.Use`), `UseExceptionHandler`, `UseStaticFiles`, `UseRouting`, `UseAuthorization`, endpoints. Как пройдёт запрос `/logo.png` и что произойдёт с исключением, брошенным в endpoint `/api/orders`?

Запрос `/logo.png` пройдёт логирование и обработчик исключений и дойдёт до middleware статических файлов. Оно находит файл, отвечает и замыкает конвейер, поэтому маршрутизация и авторизация этот запрос не увидят, а код логирования после его `next` выполнится на обратном пути. Исключение в endpoint `/api/orders` поднимется по цепочке и будет перехвачено `UseExceptionHandler`: он ловит исключения только из компонентов, стоящих после него, поэтому его ставят в начало конвейера. Исключение в самом логировании, стоящем перед ним, он не увидит. Запрос идёт по порядку регистрации, ответ в обратном.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-10.0#middleware-order

### Чем отличается middleware по соглашению (класс с `RequestDelegate` и `InvokeAsync`) от middleware на `IMiddleware` и как каждое из них создаётся?

Middleware по соглашению создаётся один раз и живёт всё время работы приложения. Класс должен иметь публичный конструктор с параметром `RequestDelegate`, а также публичный метод `Invoke` или `InvokeAsync`, который возвращает `Task` и первым параметром принимает `HttpContext`. `IMiddleware` активируется на каждый запрос через `IMiddlewareFactory`, поэтому его тип нужно зарегистрировать в контейнере как scoped или transient, а `next` приходит параметром метода `InvokeAsync(HttpContext, RequestDelegate)`.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/write?view=aspnetcore-10.0

## Контракты API в ASP.NET Core

### Есть контроллер с `[ApiController]` и Minimal API-эндпоинт на .NET 10. Оба принимают DTO с `[Required]` на поле `Name`, в Minimal API-проекте вызова `AddValidation` нет. Клиент отправляет в оба запроса без `Name`. Что произойдёт в каждом из них?

Контроллер ответит `400 Bad Request`, а Minimal API-обработчик выполнится с невалидной моделью. `[ApiController]` добавляет к контроллеру фильтр `ModelStateInvalidFilter`: при невалидном `ModelState` он прерывает запрос до вызова действия и возвращает `ValidationProblemDetails` с кодом 400. В Minimal API такой проверки нет, пока не зарегистрирован сервис валидации: `builder.Services.AddValidation()` (.NET 10) добавляет к каждому эндпоинту фильтр, который проверяет атрибуты `DataAnnotations` у параметров из query, заголовков и тела и при ошибке отвечает `400` до обработчика. Без `AddValidation` невалидные данные доходят до кода обработчика.

Источник: https://learn.microsoft.com/aspnet/core/web-api/?view=aspnetcore-10.0#automatic-http-400-responses

### В приложении зарегистрирован `IExceptionHandler` через `AddExceptionHandler<T>()`, в конвейере вызван `app.UseExceptionHandler()` без аргументов, а `AddProblemDetails()` и пути к странице ошибки нет. Что произойдёт при запуске приложения?

Приложение не запустится: `UseExceptionHandler()` без аргументов бросит `InvalidOperationException` с сообщением, что нужно задать `ExceptionHandlingPath` или `ExceptionHandler`. Middleware, вызывающее зарегистрированные `IExceptionHandler`, требует запасной вариант для исключений, которые не взял ни один из них. Запасным может быть путь (`UseExceptionHandler("/error")`), зарегистрированный `AddProblemDetails()` или делегат-запасной обработчик. Сами `IExceptionHandler` вызываются первыми, в порядке регистрации, пока один не вернёт `true` из `TryHandleAsync`; запасной вариант срабатывает, только когда все вернули `false`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/error-handling?view=aspnetcore-10.0#iexceptionhandler

### API на .NET 10 отдаёт ошибки в разных форматах: роутинг возвращает пустой `404`, `Results.BadRequest()` пустой `400`, необработанное исключение третий формат. Что настроить, чтобы все три стали ответами `ProblemDetails` без правки каждого эндпоинта?

Нужны три вызова: `builder.Services.AddProblemDetails()`, `app.UseExceptionHandler()` и `app.UseStatusCodePages()`. `AddProblemDetails` регистрирует `IProblemDetailsService`. Middleware обработки исключений и middleware кодов состояния пользуются им и пишут `ProblemDetails` для ответов с кодом 4xx и 5xx, у которых ещё нет тела: для `404` без маршрута, для пустого `400` и для необработанного исключения. Ошибки валидации идут разными путями: валидация Minimal API (.NET 10) отдаёт ответ через зарегистрированный `IProblemDetailsService`, а контроллеры с `[ApiController]` строят `ValidationProblemDetails` через собственный `ProblemDetailsFactory`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/error-handling-api?view=aspnetcore-10.0

### В новом проекте на .NET 10 в `Program.cs` нет `AddSwaggerGen`, а вызов `.WithOpenApi()` из старого кода даёт предупреждение `ASPDEPR002`. Откуда теперь берётся OpenAPI-документ и чем заменить `WithOpenApi`?

Документ строит встроенный генератор из пакета `Microsoft.AspNetCore.OpenApi`, а `WithOpenApi` заменяет `AddOpenApiOperationTransformer`. Встроенная генерация есть с .NET 9: `AddOpenApi()` регистрирует сервисы, `MapOpenApi()` публикует документ по адресу `/openapi/v1.json`. В шаблоне этот эндпоинт включён только в Development. Swashbuckle из шаблонов убран, но остаётся доступным как пакет сообщества. С .NET 10 расширение `WithOpenApi` помечено устаревшим (`ASPDEPR002`): правки описания операции переносят в `AddOpenApiOperationTransformer`, а для Swashbuckle в `IOperationFilter`. Ещё одно изменение .NET 10: документ по умолчанию имеет версию OpenAPI 3.1, выбрать другую можно через `OpenApiVersion` в параметрах `AddOpenApi`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/openapi/overview?view=aspnetcore-10.0

## HttpClient и устойчивость

### Сервис в каждом обработчике запроса создаёт `using var client = new HttpClient();` и вызывает внешний API. Под нагрузкой новые исходящие соединения начинают отказывать, хотя клиенты освобождаются. Что происходит и как это чинят?

Сервису не хватает свободных портов операционной системы. У каждого `HttpClient` свой пул соединений, привязанный к `SocketsHttpHandler`. Освобождение клиента закрывает соединения, но порт TCP после закрытия сразу не освобождается (состояние `TIME-WAIT`, RFC 9293). При высокой частоте запросов лимит портов кончается. Кроме того, каждое лишнее соединение стоит времени на установку.

Источник: https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#pooled-connections

### Singleton `HttpClient` создан при старте и работает неделями. Адрес зависимого сервиса в DNS перенесли на новые IP, старые серверы ещё работают, но трафик получать уже не должны. Часть запросов продолжает идти на прежний адрес. Почему так и что настроить?

`HttpClient` разрешает DNS только при создании соединения и не отслеживает TTL записи, а пул держит открытые соединения и переиспользует их, поэтому запросы идут на прежний IP. Срок жизни соединения ограничивает `SocketsHttpHandler.PooledConnectionLifetime`. Когда срок вышел и последний запрос по соединению завершён, соединение закрывается, и следующее открывается заново с новым запросом к DNS. Значение выбирают по ожидаемой частоте смены DNS-записей; Microsoft приводит в примерах 2 и 15 минут.

Источник: https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#dns-behavior

### На .NET 8 типизированный клиент, зарегистрированный через `AddHttpClient<TodoClient>()` с настройками по умолчанию, внедрён в singleton-сервис. Через сутки после смены DNS-записи сервис всё ещё ходит по старому адресу, хотя `IHttpClientFactory` по умолчанию заменяет обработчики каждые две минуты. Почему так и как это исправить?

Типизированный клиент создаётся один раз, при внедрении в singleton, и остаётся привязан к тому обработчику, который ему выдали. Фабрика управляет обработчиками, но клиентом после создания уже не управляет и подменить обработчик в нём не может. Ротация действует только для клиентов, которых запрашивают заново. Поэтому клиент, захваченный singleton-сервисом, не реагирует на смену DNS и подрывает смысл фабрики.

Источник: https://learn.microsoft.com/dotnet/core/extensions/httpclient-factory#avoid-typed-clients-in-singleton-services

## Безопасность и тесты в ASP.NET Core

### API защищён `AddJwtBearer` с заданными `Authority` и `Audience`. Клиент А присылает токен с корректной подписью, но с `aud` другого API. Клиент Б присылает действующий токен этого API без роли `Admin` на эндпоинт, который требует эту роль. Какие статусы получат клиенты?

Клиент А получит `401 Unauthorized`, клиент Б `403 Forbidden`. JwtBearer проверяет подпись токена, издателя (`iss`), аудиторию (`aud`) и срок действия, и неверное значение любой из этих проверок означает, что токен не принят, то есть `401` с заголовком `WWW-Authenticate`. Токен клиента А выпущен для другого API, поэтому не принят. Токен клиента Б принят, личность установлена, но роль или политика ему отказали. Это решение авторизации, и его статус `403`. API при этом не перенаправляет клиента к провайдеру удостоверений: токен получает само клиентское приложение.

Источник: https://learn.microsoft.com/aspnet/core/security/authentication/configure-jwt-bearer-authentication?view=aspnetcore-10.0#using-jwt-tokens-to-secure-an-api

### Юнит-тест вызывает метод `OrdersController.Create` напрямую и проходит, но в production `POST /orders` возвращает `415`. Почему юнит-тест этого не увидел и что поймал бы интеграционный тест через `WebApplicationFactory<Program>`?

Юнит-тест вызывает метод в обход конвейера запроса, интеграционный тест через `WebApplicationFactory` проходит его целиком. Фабрика запускает приложение в памяти на тестовом сервере, а `CreateClient()` даёт `HttpClient`, направленный в этот хост. Запрос идёт через настоящие маршрутизацию, middleware, привязку модели и форматтеры, фильтры, аутентификацию и граф зависимостей. Поэтому тест увидит `415` из-за формата тела, `404` из-за маршрута, `400` из-за валидации и сервис, который забыли зарегистрировать. Юнит-тесту всё это недоступно: он подменяет окружение заглушками.

Источник: https://learn.microsoft.com/aspnet/core/test/integration-tests?view=aspnetcore-10.0#introduction-to-integration-tests

### Интеграционный тест через `WebApplicationFactory` должен подменить внешний платёжный шлюз `IPaymentGateway` заглушкой только в одном тесте, не затрагивая остальные. Как это делается?

Через `WithWebHostBuilder` и `ConfigureTestServices`: `factory.WithWebHostBuilder(b => b.ConfigureTestServices(s => s.AddSingleton<IPaymentGateway, FakeGateway>()))`. Регистрации из `ConfigureTestServices` выполняются после тех, что сделаны в `Program.cs`, поэтому заглушка заменяет зависимость приложения. `WithWebHostBuilder` создаёт новую фабрику с этой донастройкой, так что остальные тесты по-прежнему работают с исходными сервисами. Подмену для всех тестов сразу делают в `ConfigureWebHost` собственного наследника `WebApplicationFactory`; так же заменяют и контекст базы данных.

Источник: https://learn.microsoft.com/aspnet/core/test/integration-tests?view=aspnetcore-10.0#inject-mock-services

## ASP.NET Core Конфигурация

### Из каких источников веб-сервис на ASP.NET Core собирает настройки и как код получает их в типизированном виде?

Хост собирает настройки из цепочки провайдеров (JSON-файлы, переменные окружения, аргументы командной строки, user secrets) в один плоский словарь «ключ и строковое значение», а типизированный доступ даёт паттерн Options: секция привязывается к классу, и код получает его через `IOptions<T>`, `IOptionsSnapshot<T>` или `IOptionsMonitor<T>`.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-10.0

### Singleton-сервису нужно видеть правку appsettings.json без перезапуска, а scoped-сервису достаточно одного значения на запрос. Что внедрять в каждый из них: `IOptions<T>`, `IOptionsSnapshot<T>` или `IOptionsMonitor<T>`?

В singleton внедряют `IOptionsMonitor<T>`, в scoped-сервис `IOptionsSnapshot<T>`. `IOptionsMonitor<T>` зарегистрирован как singleton: `CurrentValue` отдаёт актуальные значения в любой момент, а `OnChange` сообщает об изменении. `IOptionsSnapshot<T>` зарегистрирован как scoped: значения вычисляются один раз за запрос при первом обращении и кэшируются до его конца, поэтому в singleton его внедрить нельзя. `IOptions<T>` читает конфигурацию один раз, и правок после старта он не видит.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/options

### В каком порядке `WebApplication.CreateBuilder` подключает источники конфигурации и какой из них приоритетнее остальных?

Приоритет от высшего к низшему такой: аргументы командной строки, переменные окружения, user secrets (только в Development), `appsettings.{Environment}.json`, `appsettings.json`, резервная конфигурация хоста. Побеждает источник, добавленный последним, поэтому провайдеры подключаются в обратном порядке: от `appsettings.json` до командной строки. Благодаря этому один образ контейнера настраивают переменными окружения, а разовое значение подставляют аргументом при запуске.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-10.0

## Оптимизация производительности

### Что такое Span<T>?

`Span<T>` — `ref struct`, лёгкое «окно» на непрерывный участок памяти: массив, буфер `stackalloc` или неуправляемую память. Работать с ним можно как с массивом, не копируя данные.

Источник: https://learn.microsoft.com/dotnet/standard/memory-and-spans/

### Что такое Memory<T>?

`Memory<T>` — обычная структура-обёртка над непрерывным участком памяти, как `Span<T>`, но она может храниться в куче, поэтому её можно держать в полях классов, передавать через `await` и между потоками.

Источник: https://learn.microsoft.com/dotnet/standard/memory-and-spans/

### Когда лучше использовать циклы вместо LINQ?

Цикл `for`/`foreach` вместо LINQ оправдан на горячем пути, где замер показал, что накладные расходы LINQ заметны, а в остальном коде читаемость LINQ ценнее.

Источник: https://learn.microsoft.com/dotnet/csharp/write-safe-efficient-code

## Background Services

### Что такое фоновые службы (Background Services)?

Фоновая служба — код, который хост запускает вместе с приложением и останавливает при его завершении, независимо от HTTP-запросов и пользователя; в .NET это реализация `IHostedService`, чаще всего наследник `BackgroundService`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/host/hosted-services?view=aspnetcore-10.0

### Что такое IHostedService и BackgroundService?

`IHostedService` — интерфейс с двумя методами, `StartAsync` и `StopAsync`, которыми хост управляет службой; `BackgroundService` — абстрактный базовый класс для долгоживущей службы поверх него, в котором достаточно переопределить `ExecuteAsync`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/host/hosted-services?view=aspnetcore-10.0

### Как зарегистрировать фоновую службу в DI?

Зарегистрировать её расширением `AddHostedService<T>()`: `builder.Services.AddHostedService<MyWorkerService>();`.

Источник: https://learn.microsoft.com/aspnet/core/fundamentals/host/hosted-services?view=aspnetcore-10.0

## Современный C#: nullable, образцы, records, генераторы

### В проекте включён `<Nullable>enable</Nullable>`. Метод объявлен как `string Normalize(string name) => name.Trim();`, а вызывающий код передаёт ему значение из кода с отключённым контекстом nullable, и там оказывается `null`. Что произойдёт при выполнении и добавляет ли компилятор проверки на null для параметров без знака вопроса?

На `name.Trim()` будет брошено `NullReferenceException`, а компилятор никаких проверок вокруг параметра не добавляет.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/nullable-reference-types

### Метод `bool TryGetUser(string id, out User? user)` возвращает `true` только когда пользователь найден. После `if (TryGetUser(id, out var user))` обращение `user.Name` даёт предупреждение о возможном null. Какой атрибут и на какой элемент поставить, чтобы предупреждение исчезло без оператора `!`?

Нужен атрибут `[NotNullWhen(true)]` из `System.Diagnostics.CodeAnalysis` на out-параметре: `bool TryGetUser(string id, [NotNullWhen(true)] out User? user)`.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/nullable-analysis

### `Shape` — абстрактный класс с наследниками `Circle`, `Square` и `Triangle`. Метод записан как `int Rank(Shape s) => s switch { Circle => 1, Square => 2 };`. Что произойдёт при сборке и при вызове `Rank(new Triangle())`?

При вызове будет брошено `System.Runtime.CompilerServices.SwitchExpressionException`, а при сборке компилятор предупредит, что выражение switch обрабатывает не все возможные значения.

Источник: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/switch-expression

## Готовность к production: остановка и пробы

### Сервис ASP.NET Core в Kubernetes при каждой выкладке даёт несколько ошибок «connection refused» у клиентов, хотя процесс корректно завершается по SIGTERM и `ShutdownTimeout` хватает на все запросы. Что происходит и как это убирают?

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

Источник: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/

### В поде заданы `terminationGracePeriodSeconds: 30`, хук `preStop` с паузой 10 секунд и стандартный `HostOptions.ShutdownTimeout`. Запросы, которые идут дольше 20 секунд после получения SIGTERM, обрываются. Почему, если хост готов ждать 30 секунд, и какое условие нужно соблюсти?

Срок оркестратора идёт с начала остановки пода и включает `preStop`, поэтому хосту остаётся около 20 секунд, а не 30: затем kubelet посылает KILL.

Источник: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/

### Три копии сервиса ASP.NET Core в Kubernetes используют один эндпоинт `/health`, который проверяет подключение к PostgreSQL, и как `livenessProbe`, и как `readinessProbe`. База недоступна минуту. Что сделает оркестратор и как разделить проверки?

Провал liveness-пробы приводит к перезапуску контейнера, поэтому оркестратор перезапустит все три копии, хотя перезапуск не вернёт базу.

Источник: https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks

## Наблюдаемость в .NET: логи, метрики, трассы

### Сервис на .NET 10 пишет метрики через `Meter("Shop.Orders")` и спаны через `ActivitySource("Shop.Orders")`, но в системе мониторинга после деплоя нет ни метрик, ни трасс. Инструментирование в коде написано верно. Чего не хватает?

Не хватает сборщика и экспортёра, обычно OpenTelemetry SDK: `Meter` и `ActivitySource` только записывают измерения внутри процесса и сами ничего наружу не отправляют.

Источник: https://learn.microsoft.com/en-us/dotnet/core/diagnostics/observability-with-otel

### В коде два вызова: `logger.LogInformation("Заказ {OrderId} оплачен", id);` и `logger.LogInformation($"Заказ {id} оплачен");`. Чем различаются записи для системы логов, которая хранит поля, и почему поиск по номеру заказа находит только одну?

Первый вызов передаёт шаблон и значение отдельно, второй передаёт готовую строку, поэтому поле `OrderId` появляется только у первой записи.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/logging

### Обработка заказа вызывает десяток методов, и каждый пишет в `ILogger`. Как добавить `OrderId` ко всем этим записям, не передавая его в каждый вызов, и что нужно включить у провайдера?

Оборачивают обработку в область логирования: `using (logger.BeginScope(new Dictionary<string, object> { ["OrderId"] = id })) { ... }`. Все записи внутри блока получают это поле.

Источник: https://learn.microsoft.com/en-us/dotnet/core/extensions/logging

## Aspire, SignalR и GraphQL

### В AppHost Aspire сервис описан как `builder.AddProject<Projects.Api>("api").WithReference(db)`. При запуске API стартует раньше, чем PostgreSQL готов принимать подключения, и падает. Что делает `WithReference`, чего он не делает и что добавить?

`WithReference(db)` связывает сервис с ресурсом: API получает настройки подключения к базе, но запуск после готовности базы он не гарантирует. Нужно добавить `WaitFor(db)`.

Источник: https://learn.microsoft.com/en-us/dotnet/aspire/fundamentals/app-host-overview

### Команда хочет запускать систему из нескольких сервисов на сервере в production той же командой `aspire run`, которой пользуются разработчики. Подходит ли Aspire как среда выполнения в проде?

Нет: по документации Aspire не является облачным провайдером и средой выполнения в production, а `aspire run` описывает локальный запуск при разработке.

Источник: https://learn.microsoft.com/en-us/dotnet/aspire/get-started/aspire-overview

### Чат на SignalR работает на одном экземпляре. После масштабирования до двух экземпляров за балансировщиком сообщение, разосланное через `Clients.All`, видит только часть пользователей. Почему так и что подключают?

Каждый экземпляр хранит подключения своих клиентов в памяти и не знает о подключениях другого экземпляра, поэтому `Clients.All` доходит только до клиентов того сервера, где вызван. Для рассылки между серверами подключают backplane.

Источник: https://learn.microsoft.com/en-us/aspnet/core/signalr/scale

## gRPC и выбор специализации

### Клиент gRPC на .NET вызывает сервис, который иногда зависает на внешнем вызове. Клиент ждёт ответа бесконечно. Что нужно настроить, что получит клиент при срабатывании и продолжит ли работать серверный метод?

Дедлайна по умолчанию в gRPC нет: вызовы не ограничены по времени, пока клиент его не задаст. Его указывают в параметре `deadline` вызова, например `deadline: DateTime.UtcNow.AddSeconds(5)`.

Источник: https://learn.microsoft.com/en-us/aspnet/core/grpc/deadlines-cancellation

### В ASP.NET Core нужно в реальном времени рассылать сообщения чата всем подключённым браузерам комнаты. Команда сначала думает взять для этого gRPC-стриминг. Что в gRPC будет мешать и какую технологию из экосистемы ASP.NET Core выбрать?

Лучше взять SignalR. В gRPC нет понятия рассылки сообщения по зарегистрированным соединениям: стриминг поддерживается, но каждый вызов должен отдельно отправлять новые сообщения своему клиенту, а список подписчиков и их учёт придётся писать самим. В документации ASP.NET Core именно этот сценарий, чат, назван случаем, где подходит SignalR.

Источник: https://learn.microsoft.com/en-us/aspnet/core/grpc/comparison

## Диагностика работающего .NET-сервиса

### Сервис в проде перестал отвечать на запросы, загрузка процессора около нуля, число потоков растёт. Подозрение: потоки ждут друг друга на `lock`. Какой из консольных инструментов диагностики .NET даёт состояние потоков и владельца блокировки у работающего процесса и какими командами это смотрят?

Нужен `dotnet-dump`: он снимает дамп процесса и анализирует его командами SOS на Windows, Linux и macOS.

Источник: https://learn.microsoft.com/en-us/dotnet/core/diagnostics/debug-deadlock

### Сервис в проде держит процессор около 90% при обычной нагрузке. Нужно узнать, какие методы потребляют время. Каким консольным инструментом диагностики .NET собирают такие данные и что получается на выходе?

Данные собирает `dotnet-trace collect`, на выходе файл трассировки `.nettrace` с выборками стеков. Перед сбором симптом обычно подтверждают через `dotnet-counters`: он показывает в реальном времени значения счётчиков, в том числе загрузку процессора, и годится для первичного расследования.

Источник: https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-trace

## Хостинг и жизненный цикл приложения

### Сервис на ASP.NET Core 10 работает в контейнере. При выкладке контейнер получает SIGTERM, а размещённая служба (`IHostedService`) завершает `StopAsync` за 45 секунд. Что сделает хост и что произойдёт со службой?

Хост подождёт `ShutdownTimeout` (по умолчанию 30 секунд) и завершит процесс, не дожидаясь службы: оставшиеся службы останавливаются вместе с приложением, даже если ещё что-то обрабатывают.

Источник: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host?view=aspnetcore-10.0

## Тестируемость кода

### Метод `Subscription.IsExpired()` сравнивает дату окончания с `DateTime.UtcNow`, и тест на него то проходит, то падает, а проверить границу в 23:59:59 нельзя. Как сделать код тестируемым в .NET 10, не заводя собственный интерфейс часов?

Принять в класс `TimeProvider` из стандартной библиотеки и брать время из `GetUtcNow()`, а в тесте подставить `FakeTimeProvider`.

Источник: https://learn.microsoft.com/en-us/dotnet/api/system.timeprovider

## Контейнеры и конвейер сборки .NET

### Сервис на .NET 8 в образе `mcr.microsoft.com/dotnet/aspnet:8.0` запущен командой `docker run -p 8000:80 my-app`. Раньше на .NET 7 такая команда работала, теперь `curl localhost:8000` получает сброс соединения. Почему и как исправить?

Начиная с .NET 8 в образах Microsoft приложение ASP.NET Core по умолчанию слушает порт 8080, а не 80, поэтому проброшенный порт 80 внутри контейнера никто не слушает.

Источник: https://learn.microsoft.com/en-us/dotnet/core/compatibility/containers/8.0/aspnet-port

### Образ ASP.NET Core 10-сервиса получился заметно больше, чем ожидалось: Dockerfile начинается с `FROM mcr.microsoft.com/dotnet/sdk:10.0`, и на этом образе же сервис запускается. Как собрать образ правильно?

Сделать Dockerfile многостадийным: собирать и публиковать на образе `dotnet/sdk`, а в конечный образ копировать только результат публикации поверх `dotnet/aspnet`.

Источник: https://learn.microsoft.com/en-us/dotnet/core/docker/container-images

### В конвейере сборки .NET-сервиса стоит `dotnet restore --locked-mode`. Что именно этот шаг гарантирует и когда он не защищает вообще?

Шаг гарантирует, что восстановлены ровно те версии пакетов, что записаны в `packages.lock.json`, а если зависимости проекта изменились после создания lock-файла, восстановление завершается ошибкой.

Источник: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-restore
