Асинхронность и async/await

Блокирующий вызов удерживает поток до завершения операции. await вместо этого регистрирует продолжение и возвращает поток в пул, и тот обслуживает другую работу, пока операция выполняется. Это даёт пропускную способность и отзывчивость, но никогда не скорость.

async void не возвращает Task, поэтому вызывающий не может его ожидать, не видит момента завершения и не может поймать его исключение — сбой перебрасывается на захваченный контекст и роняет процесс. Используйте async Task везде, кроме обработчиков событий, чья сигнатура вынуждает void.

CancellationToken — это сигнал только для чтения, который вызывающий передаёт вниз, чтобы вызываемый код увидел запрос на отмену. Взвести его может лишь владелец, CancellationTokenSource, вызовом Cancel(). Сам токен ничего не останавливает — он лишь сообщает IsCancellationRequested.

Task — это дескриптор уже идущей операции, обещание будущего результата, а не поток и не сама работа. Он завершается как RanToCompletion, Faulted с исключением или Canceled; Task<T> вдобавок несёт полученное значение.

Task.WhenAll возвращает задачу, которая завершается, когда закончилась каждая из входных, и отдаёт все результаты разом. Task.WhenAny завершается по первой закончившейся и отдаёт именно её; остальные продолжают работать. Обе нужно ожидать через await, а не блокировать.

За вводом-выводом не стоит поток — работает устройство, а ОС держит колбэк завершения, поэтому await может полностью отпустить поток. Вычислительной работе всё время нужно исполнять инструкции, так что какой-то поток на ней сидит; Task.Run освобождает вызывающего, но всё равно тратит поток из пула.

await FooAsync() стартует метод на текущем потоке и выполняет его прямо здесь до первого настоящего await. Task.Run сначала отдаёт делегат потоку из пула, и синхронный пролог выполняется уже там. Для I/O-bound работы этот лишний прыжок не даёт ничего и лишь тратит поток.

Блокирующие API — .Wait(), .Result, Task.WaitAll — заворачивают сбои в AggregateException, ведь упасть могло сразу несколько задач. await же разворачивает её и перебрасывает только первое внутреннее исключение, поэтому упавший Task.WhenAll бросит одно; остальные останутся в Exception.InnerExceptions задачи.

Отмена кооперативна — никто не прервёт метод за вас. Он обязан прокидывать токен в каждый вызов, который ожидает, и вызывать ThrowIfCancellationRequested() между порциями работы. Это бросает OperationCanceledException, и задача попадает в Canceled, а не в Faulted.

Task<List<T>> ожидается один раз и материализует всю пачку в памяти. IAsyncEnumerable<T> отдаёт элементы по одному и может делать await между ними, поэтому await foreach обрабатывает первый элемент, пока следующие ещё едут, — это поток без буферизации всего сразу.

Task<T> — класс, поэтому каждый вызов выделяет объект, даже когда результат уже закеширован. ValueTask<T> — структура, оборачивающая либо значение, либо Task<T>, поэтому синхронно завершившийся горячий путь не выделяет ничего. Подвох: ожидать его нужно ровно один раз, никогда не дважды.

У вызова пропущен await, поэтому возвращённая Task просто отбрасывается. async-метод не бросает исключение в кадр вызывающего — он складывает сбой в свою Task и перебрасывает его только при ожидании этой задачи. Исправление: написать await _repository.SaveAsync(order);.

Упавший async Task-метод ловит исключение внутри своей машины состояний и складывает его в задачу через SetException; awaiter затем перебрасывает его через ExceptionDispatchInfo, сохраняя исходный стек вместо его сброса. У async void задачи для хранения нет, поэтому его builder перебрасывает исключение на захваченный SynchronizationContext — или в пул потоков, — где никто не ожидает, и процесс падает.

Компилятор переписывает метод в машину состояний, чей MoveNext() возобновляет работу на каждом await; локальные переменные становятся её полями. На await она спрашивает у awaiter, завершена ли операция: если да — исполнение продолжается прямо здесь; если нет — builder упаковывает машину в кучу, вешает MoveNext продолжением, и поток уходит. Завершение операции снова входит в MoveNext на сохранённом состоянии.

Потребитель отменяет поток через await foreach (... .WithCancellation(ct)), и этот токен уходит в GetAsyncEnumerator(ct) — а не в собственные параметры итератора, которые были связаны ещё при первом вызове метода. [EnumeratorCancellation] велит компилятору направить токен уровня перечислителя в помеченный параметр, связав его с тем токеном, что передали при вызове.