Backend Developer C# / .NET

Семантика языка C# и её последствия для производительности: модель типов и обобщения, делегаты и события, исключения, время жизни ресурсов, а также продвинутый слой — pattern matching, records, expression trees, reflection и source generators.

1. Как устроены обобщения в .NET
2. Делегаты и события — модель и распространённые ловушки
3. Исключения: стоимость, типы, паттерны и анти-паттерны
4. IDisposable, using и финализаторы
5. Nullable reference types — что они на самом деле делают
6. Сопоставление с образцом: тест и сужение в одном выражении
7. Records: равенство по значению, with и деконструкция
8. Деревья выражений: лямбда как данные, описывающие код
9. Reflection: модель метаданных и её стоимость
10. Source generators — компиляторное метапрограммирование
11. Строки: интернирование, StringBuilder и стоимость конкатенации
12. Равенство и хеш-код: контракт Equals/GetHashCode и упаковка

Как устроена среда выполнения .NET: загрузка сборок и типов, JIT-компиляция, управление памятью и сборка мусора, пул потоков, граница managed/unmanaged, Native AOT и P/Invoke. Помогает отличать гарантии языка от поведения кода под нагрузкой.

1. Архитектура CLR: загрузчик, JIT, GC, метаданные
2. JIT, многоуровневая компиляция и ReadyToRun
3. Сборки и загрузка типов в .NET
4. GC: поколения, фазы, mark/sweep/compact
5. Сборщик мусора: server и workstation, задержка против пропускной способности
6. Large Object Heap и фрагментация
7. Managed и unmanaged ресурсы: SafeHandle, IDisposable, ArrayPool
8. Как работает пул потоков и планирование в .NET
9. Native AOT: что включается, что выключается
10. P/Invoke и interop — что происходит на границе

Асинхронность и многопоточность в .NET: модель async/await и Task как конечный автомат, отличие асинхронной работы от параллелизма, композиция задач, кооперативная отмена и типичные ошибки вроде блокирующих вызовов и взаимоблокировок.

1. Что делают async и await на самом деле
2. Композиция задач: WhenAll, WhenAny и параллельный ввод-вывод
3. Отмена и таймауты: CancellationToken и кооперативная отмена
4. Асинхронные потоки: IAsyncEnumerable и await foreach

Коллекции и их стоимость по памяти и времени, и LINQ как декларативный слой запросов: отложенное выполнение, разница между IEnumerable и IQueryable и момент материализации запроса.

1. Коллекции и их стоимость: выбор по памяти и времени
2. LINQ — внутренняя модель, IEnumerable, deferred execution
3. IEnumerable и IQueryable: где выполняется запрос и когда материализуется

Значимые и ссылочные типы, их размещение в стеке и куче, упаковка, выбор между struct и record, а также работа с буферами без лишних аллокаций (Span, Memory, stackalloc) и unsafe-контекст. От этих решений зависит нагрузка на сборщик мусора.

1. Значимые и ссылочные типы в C#
2. Struct vs class на границе производительности
3. Span<T>, Memory<T> и stackalloc — работа с буферами без копий
4. Unsafe-контекст и указатели в C#

Доступ к общему состоянию из нескольких потоков без гонок и взаимоблокировок: примитивы синхронизации (lock, SemaphoreSlim, Interlocked), модель памяти и видимость изменений, потокобезопасные коллекции и Channels, параллельные паттерны.

1. lock, Monitor и гонки данных: модель памяти и видимость
2. SemaphoreSlim и асинхронная координация: почему lock не дружит с await
3. Interlocked и основы lock-free: атомарные операции и CAS
4. Потокобезопасные коллекции и Channels
5. Параллельные паттерны: Parallel.For/ForEach и PLINQ

Как устроено приложение ASP.NET Core: модель хостинга и запуск через Program.cs, система конфигурации с приоритетом источников и паттерн Options для типобезопасного доступа к настройкам.

1. Хостинг и запуск: WebApplication и Program.cs
2. Система конфигурации: провайдеры и приоритет источников
3. Паттерн Options: IOptions, IOptionsSnapshot, IOptionsMonitor

Контейнер внедрения зависимостей в .NET: регистрация сервисов, время жизни transient/scoped/singleton, захват зависимости через несовместимое время жизни и продвинутые способы регистрации.

1. Контейнер DI и регистрация сервисов
2. Время жизни сервисов: transient, scoped, singleton
3. Захваченные зависимости и утечки через время жизни
4. Продвинутая регистрация: keyed-сервисы, открытые обобщения, коллекции

Конвейер обработки запроса в ASP.NET Core: middleware и значение их порядка, маршрутизация запроса к обработчику и привязка модели — откуда обработчик получает свои аргументы.

1. Конвейер middleware: порядок и короткое замыкание
2. Маршрутизация и endpoints: как запрос находит обработчик
3. Привязка модели: откуда берутся аргументы обработчика

Семантика HTTP независимо от фреймворка: методы и коды состояния, безопасность и идемпотентность, кэширование с условными запросами и согласование содержимого — основа предсказуемого API.

1. HTTP-методы и коды состояния: что они означают
2. Безопасность и идемпотентность методов
3. Кэширование и условные запросы: Cache-Control и ETag
4. Согласование содержимого: Accept и форматтеры

Контракт API как обещание клиентам: валидация входных данных, единый формат ошибок, описание через OpenAPI и версионирование, чтобы изменения сервиса не ломали потребителей.

1. Валидация модели: DataAnnotations и ModelState
2. Единый контракт ошибок: ProblemDetails (RFC 9457)
3. Описание API через OpenAPI
4. Версионирование API

Как ORM работает поверх реляционной БД: DbContext и отслеживание изменений, трансляция LINQ в SQL, загрузка связанных данных, миграции и стоимость материализации. Где EF Core экономит время, а где порождает лишние запросы — и когда дешевле Dapper.

1. DbContext и отслеживание изменений
2. IQueryable против IEnumerable и трансляция запроса в SQL
3. Загрузка связанных данных: lazy, eager и explicit
4. AsNoTracking, SplitQuery и стоимость материализации
5. Миграции: модель, обратная совместимость и откат
6. Сырой SQL, хранимые процедуры и блокировки строк
7. Dapper против EF Core: когда ORM лишний

Как ASP.NET Core реализует аутентификацию и авторизацию: схемы и обработчики, проверка JWT через JwtBearer, авторизация на ролях, claim'ах и политиках, а также безопасное хранение секретов через конфигурацию. Сами протоколы (OAuth2/OIDC/JWT) — отдельный курс; здесь — их прикладной слой в .NET.

1. Аутентификация в ASP.NET Core: схемы и обработчики
2. Проверка JWT через JwtBearer
3. Авторизация: роли, claim'ы и политики
4. Конфигурация и секреты в .NET

Что отличает рабочий сервис от учебного: тесты, наблюдаемость, устойчивость к сбоям, фоновые задачи и предсказуемый деплой — свойства, которые закладываются в код, а не добавляются потом. Модуль задаёт рамку секции и разбирает один сквозной механизм хостинга — корректное завершение процесса под управлением оркестратора.

1. Что отличает продакшн-сервис от учебного
2. Жизненный цикл хоста и graceful shutdown

Тесты фиксируют поведение сервиса и защищают от регрессий: пирамида юнит-, интеграционных и end-to-end тестов, изоляция зависимостей через тестовые двойники и проектирование кода под проверяемость. Модуль разбирает, что тестировать на каждом уровне, как заменять зависимости и как проверять код, завязанный на время и базу данных.

1. Пирамида тестов: что проверять на каждом уровне
2. Юнит-тесты и тестовые двойники
3. Проектирование под тестируемость
4. Интеграционные тесты ASP.NET Core

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

1. Три канала наблюдаемости: логи, метрики, трассировки
2. Структурированные логи и сквозной идентификатор
3. Health-проверки и пробы оркестратора
4. Метрики и распределённая трассировка

Сетевые вызовы падают, и сервис должен переживать частичные отказы без каскада: правильное время жизни HttpClient, повторы с таймаутом и выдержкой, размыкатель цепи и деградация вместо полного отказа. Модуль начинает с самой частой .NET-ошибки — исчерпания сокетов из-за неверного обращения с HttpClient — и доводит до набора политик устойчивости.

1. HttpClient и исчерпание сокетов
2. Повторы, таймауты и выдержка
3. Размыкатель цепи и деградация

Длительная работа не должна жить в обработчике HTTP-запроса: её выносят в фоновые сервисы, которые живут весь срок процесса. Модуль разбирает hosted-сервисы и их жизненный цикл, типичную ошибку со scoped-зависимостью внутри singleton, очереди работы внутри процесса через Channels и границу, за которой нужна уже внешняя очередь сообщений.

1. Hosted-сервисы и их жизненный цикл
2. Очереди внутри процесса и Channels

Воспроизводимая сборка делает деплой предсказуемым: сервис упаковывают в контейнер из небольшого образа, конфигурацию выносят в переменные окружения, а сборку, тесты и публикацию автоматизируют конвейером. Модуль разбирает multi-stage Dockerfile для .NET и базовый pipeline сборки и доставки — тонко, по реальному спросу junior/middle.

1. Контейнеризация .NET-сервиса
2. Конвейер сборки и доставки

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

1. Когда тянуться к специализации

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

1. Измерять, а не угадывать
2. Инструменты диагностики .NET

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

1. .NET Aspire и локальная оркестрация

Как gRPC устроен в .NET на практике: контракт в файле .proto, из которого генерируются и сервис, и типизированный клиент, поверх HTTP/2 с бинарным форматом Protobuf и поддержкой стриминга. Модуль — про реализацию gRPC в ASP.NET Core; решение «gRPC или REST» разбирает курс по архитектуре.

1. gRPC на .NET: контракт и реализация

Обычно .NET компилирует код в нативный на лету (JIT) при запуске. Native AOT компилирует приложение в нативный код заранее, при сборке: быстрее старт и меньше потребление памяти ценой ограничений на рефлексию и совместимость. Модуль показывает, что даёт AOT и почему это выбор для специфичных нагрузок, а не дефолт.

1. Native AOT и его компромиссы

Два специализированных способа общения клиента и сервера: двусторонняя связь в реальном времени через WebSockets и SignalR, когда сервер должен сам слать обновления клиенту, и гибкие запросы через GraphQL, когда клиент хочет сам выбирать, какие данные получить. Модуль показывает, какую задачу решает каждый и какой операционной ценой.

1. Real-time: WebSockets и SignalR
2. GraphQL: клиент выбирает данные