C# C# · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Сложный · 👥 1 прошёл

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

Проверяет модель async/await без мифов о «новом потоке»: состояние Task, контекст продолжения, ValueTask, распространение ошибок и наблюдение фоновой работы. Кодовые вопросы требуют точно восстановить порядок и понять, где ожидание освобождает поток, а где блокирует его.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. В заданиях с кодом учитывайте указанную конструкцию и не додумывайте отсутствующие условия. После завершения откроются общий результат, тематические шкалы и разбор каждого ответа.

Вопрос 1 из 25

Что представляет Task<int>?

Операцию, завершающуюся значением int, ошибкой или отменой Делегат, который ещё не был вызван и не имеет состояния Коллекцию значений int с отложенным перечислением Поток из пула, зарезервированный до появления значения int Отдельный поток ОС, внутри которого хранится int

Вопрос 2 из 25

Когда начнётся выполнение LoadAsync?

var task = LoadAsync();
Console.WriteLine("task obtained");
var data = await task;

Сразу при вызове до первого незавершённого await При чтении Result После передачи делегата в Task.Run; обычный вызов лишь создаёт описание операции После первого await вызывающего метода, даже если LoadAsync уже вызван После первого обращения к свойству Status возвращённой задачи

Вопрос 3 из 25

Для чего Task.Run уместен в серверном коде?

Чтобы оборачивать каждый метод с await в дополнительную задачу Чтобы устранить возможный null в результате асинхронного метода Для ограниченной работы процессора, которую осознанно переносят в пул потоков Чтобы гарантировать запуск вычисления в отдельном процессе ОС Чтобы превратить обычный сетевой запрос в неблокирующую операцию

Вопрос 4 из 25

Что даст Task.FromResult(5)?

Task<int> cached = Task.FromResult(5);
Console.WriteLine(cached.IsCompletedSuccessfully);

Task, уже успешно завершённый значением 5 Исключение Отменённый Task Новый поток, печатающий 5 ValueTask без результата

Вопрос 5 из 25

Когда нужен TaskCompletionSource<T>?

var tcs = new TaskCompletionSource<string>(
    TaskCreationOptions.RunContinuationsAsynchronously);
legacy.Begin(value => tcs.TrySetResult(value), error => tcs.TrySetException(error));
return tcs.Task;

Для сортировки задач Чтобы преобразовать исключение callback в успешный Task со значением по умолчанию Чтобы сделать синхронный метод асинхронным без внешнего события завершения Преобразовать callback или событие в Task Чтобы создать Thread

Вопрос 6 из 25

Что делает await незавершённой задачи?

Блокирует текущий поток до завершения операции Отменяет задачу и возвращает значение по умолчанию Регистрирует продолжение, возвращает управление и возобновляет метод после завершения задачи Создаёт отдельный поток и переносит туда оставшуюся часть метода Продолжает метод сразу, не дожидаясь результата задачи

Вопрос 7 из 25

Почему два await здесь выполняются в основном последовательно?

var user = await LoadUserAsync(id);
var orders = await LoadOrdersAsync(id);

Task не поддерживает сеть Методы имеют одинаковое имя await внутри одного метода запрещает запускать две операции до общего ожидания Первый await удерживает текущий поток до завершения операции Второй вызов начинается после первого await

Вопрос 8 из 25

Как запустить две независимые операции до ожидания?

var userTask = LoadUserAsync(id);
var ordersTask = LoadOrdersAsync(id);
await Task.WhenAll(userTask, ordersTask);
var user = await userTask;
var orders = await ordersTask;

await первую, затем вызвать вторую Обернуть всё в lock Вызвать .Result у обеих Запустить обе Task, затем ожидать их вместе Использовать Thread.Sleep

Вопрос 9 из 25

Что происходит при await уже успешно завершённого Task?

Возникает InvalidOperationException Task запускается повторно Даже завершённая задача требует переключения на другой поток перед продолжением Результат теряется Продолжение может идти синхронно без приостановки

Вопрос 10 из 25

Почему ValueTask нельзя бездумно await-ить несколько раз?

ValueTask<int> valueTask = reader.ReadAsync(token);
var first = await valueTask;
var second = await valueTask;

Источник ValueTask может разрешать только одно получение результата Повторное ожидание гарантированно превращает успешный результат в отмену ValueTask не способен содержать уже вычисленное значение ValueTask является ref struct и поэтому не может храниться в локальной переменной Оператор await не поддерживает тип ValueTask

Вопрос 11 из 25

Зачем UI-коду обычно возвращаться в захваченный контекст?

Контекст ускоряет сетевой вызов, направляя его на поток пользовательского интерфейса Возврат в контекст подавляет исключения, возникшие после await в обработчике интерфейса Захваченный контекст делает Task холодным и запускает операцию только при ожидании Чтобы сериализовать JSON Чтобы продолжение могло безопасно менять элементы интерфейса

Вопрос 12 из 25

Что меняет ConfigureAwait(false) у данного await?

var bytes = await stream.ReadAsync(buffer, token).ConfigureAwait(false);
Process(bytes);

Заставляет вызывающий метод выполняться синхронно до конца Не требует возобновлять продолжение именно в захваченном контексте Отключает SynchronizationContext для всей операции и всех последующих методов Преобразует исключение операции в значение по умолчанию Переносит сам ReadAsync на новый поток из пула

Вопрос 13 из 25

Почему ConfigureAwait(false) не исправляет CPU-блокировку до await?

Он запрещает синхронный код Он влияет на синхронную часть лишь для операций, возвращающих числовой результат Он заменяет алгоритм Он уменьшает CPU вдвое Он влияет лишь на продолжение после этого await

Вопрос 14 из 25

Есть ли стандартный SynchronizationContext запроса в ASP.NET Core?

Контекст устанавливается только для MVC-контроллеров, но не для middleware Контекст создаёт каждый контроллер вручную Да, запросы привязаны к одному контекстному потоку Обычно нет; продолжение не привязано к исходному потоку запроса Контекст запроса появляется после первого Task.Run и привязывает продолжение к исходному потоку

Вопрос 15 из 25

Почему correlation id из AsyncLocal часто сохраняется через await?

Correlation.Current.Value = requestId;
await CallDependencyAsync();
log.LogInformation("Request {Id}", Correlation.Current.Value);

Значение AsyncLocal живёт в статическом поле процесса ExecutionContext переносится с продолжением ConfigureAwait(false) очищает локальный контекст Task сериализует значение Продолжение обязано выполняться на том же потоке

Вопрос 16 из 25

Где будет поймано исключение?

try
{
    await LoadAsync();
}
catch (HttpRequestException ex)
{
    Handle(ex);
}

Нигде В catch вокруг await Исключение можно перехватить лишь внутри LoadAsync, потому что Task не переносит ошибки На этапе компиляции В обработчике UnobservedTaskException после завершения метода

Вопрос 17 из 25

Почему try/catch только вокруг вызова без await не ловит поздний сбой?

Task task;
try { task = LoadAsync(); }
catch { /* не ловит сбой после await внутри LoadAsync */ }
await task;

Потому что исключение возникает в другом потоке и требует Monitor Task преобразует исключение в успешный результат по умолчанию Позднее исключение записывается в возвращённый Task Вызов async-метода не может завершиться faulted до первого await catch вокруг вызова работает только для методов, возвращающих нечисловой Task

Вопрос 18 из 25

Почему async void следует оставлять в основном для обработчиков событий?

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

Вопрос 19 из 25

Как получить все исключения нескольких задач, если это важно?

var tasks = calls.Select(CallAsync).ToArray();
var all = Task.WhenAll(tasks);
try { await all; }
catch
{
    foreach (var t in tasks.Where(t => t.IsFaulted)) Log(t.Exception);
    throw;
}

Ограничиться первым исключением, которое выбросил await WhenAll Очистить список Использовать async void Ожидать первую задачу и считать её ошибку представительной для всей группы Сохранить задачи и проверить каждую после WhenAll

Вопрос 20 из 25

Как безопаснее владеть фоновой задачей в сервисе?

Сохранить задачу в поле, не наблюдая отдельно её завершение Спрятать Task в локальной переменной и забыть Передать задачу управляемому BackgroundService или очереди Ловить Exception и молчать Использовать finalizer

Вопрос 21 из 25

Как должен выглядеть тест async-метода в xUnit?

[Fact]
public async Task Load_returns_item()
{
    var item = await sut.LoadAsync(7);
    Assert.Equal(7, item.Id);
}

Thread, который запускает Assert Task без await и без return async void void с .Wait() async Task с await проверяемого вызова

Вопрос 22 из 25

Чем заменить Thread.Sleep в тесте гонки завершения?

Повторять тест до тех пор, пока задачи завершатся в нужном порядке TaskCompletionSource/каналом/барьером, который тест контролирует явно DateTime.Now в цикле Использовать настоящий таймер с очень маленькой задержкой Использовать короткий Delay с запасом относительно обычного времени выполнения

Вопрос 23 из 25

Как проверить исключение async-метода?

await Assert.ThrowsAsync<InvalidOperationException>(
    () => sut.ProcessAsync(invalidInput));

Перехватить Exception вокруг создания Task без await Проверить IsFaulted сразу после вызова, не дожидаясь завершения задачи Assert.Throws вокруг делегата, который не await-ится await Assert.ThrowsAsync<T>(() => sut.RunAsync()) Проверить task == null

Вопрос 24 из 25

Что полезно передавать в Activity при внешнем async-вызове?

using var activity = source.StartActivity("catalog.get");
activity?.SetTag("peer.service", "catalog");
try { return await client.GetAsync(id, token); }
catch (Exception ex) { activity?.SetStatus(ActivityStatusCode.Error, ex.Message); throw; }

Идентификатор текущего потока как единственный идентификатор операции Передать только имя локального метода без адреса зависимости и результата вызова Добавить все заголовки запроса без фильтра, чтобы трасса была максимально полной Операцию, endpoint, статус и длительность Пароль и полный ответ

Вопрос 25 из 25

Какие метрики лучше показывают проблемы async-зависимости?

Количество Task в heap без контекста Число методов с await Смотреть только число потоков процесса без длительности, ошибок и конкуренции вызовов Длительность, частота ошибок, таймауты и число одновременных запросов Общее число созданных Task без разбивки по зависимости и исходу

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу