Какова правильная реализация Task.WhenAll () для этого сценария? [Дубликат]

Вы можете использовать Task.WhenAll, как указано, или Task.WaitAll, в зависимости от того, хотите ли вы, чтобы нить подождал. Взгляните на ссылку для объяснения того и другого.

WaitAll vs WhenAll

Используйте Task.WhenAll, а затем ждите результатов:

var tCat = FeedCat();
var tHouse = SellHouse();
var tCar = BuyCar();
await Task.WhenAll(tCat, tHouse, tCar);
Cat cat = await tCat;
House house = await tHouse;
Tesla car = await tCar; 
//as they have all definitely finished, you could also use Task.Value.

Если вы используете C # 7, вы можете использовать удобный метод обертки, подобный этому ...

public static class TaskEx
{
    public static async Task<(T1, T2)> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
    {
        await Task.WhenAll(task1, task2);
        return (task1.Result, task2.Result);
    }
}

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

var (someInt, someString) = await TaskEx.WhenAll(GetIntAsync(), GetStringAsync());

Учитывая три задачи: FeedCat(), SellHouse() и BuyCar(), есть два интересных случая: либо они все завершаются синхронно (по какой-то причине, возможно, кэширование или ошибка), либо они не делают.

Скажем, у нас есть вопрос:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = FeedCat();
    Task<Tesla> z = FeedCat();
    // what here?
}

. Теперь простой подход будет:

Task.WhenAll(x, y, z);

, но ... это не удобный для обработки результатов; мы обычно хотели бы await, что:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = FeedCat();
    Task<Tesla> z = FeedCat();

    await Task.WhenAll(x, y, z);
    // presumably we want to do something with the results...
    return DoWhatever(x.Result, y.Result, z.Result);
}

, но это делает много накладных расходов и выделяет различные массивы (включая массив params Task[]) и списки (внутренне). Это работает, но это не очень хорошая ИМО. Во многих отношениях проще использовать операцию async и только await каждый по очереди:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = FeedCat();
    Task<Tesla> z = FeedCat();

    // do something with the results...
    return DoWhatever(await x, await y, await z);
}

Вопреки некоторым комментариям выше, использование await вместо Task.WhenAll делает не отличается от того, как выполняются задачи (одновременно, последовательно и т. д.). На самом высоком уровне Task.WhenAll предшествует хорошей поддержке компилятора для async / await и полезен , когда эти вещи не существовали . Это также полезно, когда у вас есть произвольный массив задач, а не 3 сдержанных задач.

Но: у нас все еще есть проблема, что async / await генерирует много шума компилятора для продолжения , Если вероятность того, что задачи действительно завершится синхронно, , мы можем оптимизировать это, построив синхронный путь с асинхронным резервным копированием:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = FeedCat();
    Task<Tesla> z = FeedCat();

    if(x.Status == TaskStatus.RanToCompletion &&
       y.Status == TaskStatus.RanToCompletion &&
       z.Status == TaskStatus.RanToCompletion)
        return Task.FromResult(
          DoWhatever(a.Result, b.Result, c.Result));
       // we can safely access .Result, as they are known
       // to be ran-to-completion

    return Awaited(x, y, z);
}

async Task Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
    return DoWhatever(await x, await y, await z);
}

Этот «путь синхронизации с async fallback "становится все более распространенным, особенно в высокопроизводительном коде, где синхронные завершения относительно часты. Обратите внимание, что это вообще не поможет, если завершение всегда истинно асинхронно.

Дополнительные действия, которые применяются здесь:

1: с недавним C #, общий шаблон для async метод резервного копирования обычно реализуется как локальная функция:

Task<string> DoTheThings() {
    async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
        return DoWhatever(await a, await b, await c);
    }
    Task<Cat> x = FeedCat();
    Task<House> y = FeedCat();
    Task<Tesla> z = FeedCat();

    if(x.Status == TaskStatus.RanToCompletion &&
       y.Status == TaskStatus.RanToCompletion &&
       z.Status == TaskStatus.RanToCompletion)
        return Task.FromResult(
          DoWhatever(a.Result, b.Result, c.Result));
       // we can safely access .Result, as they are known
       // to be ran-to-completion

    return Awaited(x, y, z);
}

2: предпочитает ValueTask<T> - Task<T>, если есть хорошие шансы на вещи когда-либо полностью синхронно со многими различными значениями возврата:

ValueTask<string> DoTheThings() {
    async ValueTask<string> Awaited(ValueTask<Cat> a, Task<House> b, Task<Tesla> c) {
        return DoWhatever(await a, await b, await c);
    }
    ValueTask<Cat> x = FeedCat();
    ValueTask<House> y = FeedCat();
    ValueTask<Tesla> z = FeedCat();

    if(x.IsCompletedSuccessfully &&
       y.IsCompletedSuccessfully &&
       z.IsCompletedSuccessfully)
        return new ValueTask<string>(
          DoWhatever(a.Result, b.Result, c.Result));
       // we can safely access .Result, as they are known
       // to be ran-to-completion

    return Awaited(x, y, z);
}

3: если возможно, предпочитайте IsCompletedSuccessfully - Status == TaskStatus.RanToCompletion; это теперь существует в .NET Core для Task и везде для ValueTask<T>

Вы можете сохранить их в задачах, а затем ждать их всех:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

Cat cat = await catTask;
House house = await houseTask;
Car car = await carTask;

Просто await три задачи отдельно, после их запуска.

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

var cat = await catTask;
var house = await houseTask;
var car = await carTask;