Запуск декількох завдань асинхронізації та очікування їх завершення

Мені потрібно запустити кілька завдань на асинхронізацію в консольному додатку та дочекатися їх завершення перед подальшою обробкою.

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

Я розумію, що можна ланцюжок завдань таким чином, щоб вони починалися після того, як закінчується інше (що в значній мірі є сценарієм для всіх прочитаних статей), але я хочу, щоб усі мої завдання виконувалися одночасно, і я хочу знати це один раз вони всі завершені.

Яка найпростіша реалізація для такого сценарію?

Обидві відповіді не згадували очікуваного Task.WhenAll:

var task1 = DoWorkAsync();
var task2 = DoMoreWorkAsync();

await Task.WhenAll(task1, task2);

Основна відмінність між Task.WaitAllі Task.WhenAllполягає в тому, що перший заблокує (подібно до використання Waitв одному завданні), тоді як останнього не буде і на нього можна очікувати, повертаючи управління абоненту, поки всі завдання не закінчаться.

Тим більше, що обробка виключень відрізняється:

Task.WaitAll:

Принаймні один із екземплярів Завдання було скасовано - або виняток було викинуто під час виконання принаймні одного з екземплярів Завдання. Якщо завдання було скасовано, AggregateException містить в своїй колекції InnerExceptions OperationCanceledException.

Task.WhenAll:

Якщо будь-яке із заданих завдань завершиться у несправному стані, повернене завдання також буде виконане у стані Faulted, де його винятки містять агрегацію набору нерозгорнутих винятків з кожної із заданих задач.

Якщо жодне із поданих завдань не вийшло, але принаймні одне з них було скасовано, повернене завдання закінчиться у відміненому стані.

Якщо жодне із завдань не вийшло з ладу і жодне із завдань не було скасовано, отримане завдання закінчиться у стані RanToCompletion. Якщо наданий масив / перечислювальний ряд не містить завдань, повернене завдання негайно перейде до стану RanToCompletion, перш ніж воно повернеться до абонента.

Ви можете створити багато завдань, таких як:

List<Task> TaskList = new List<Task>();
foreach(...)
{
   var LastTask = new Task(SomeFunction);
   LastTask.Start();
   TaskList.Add(LastTask);
}

Task.WaitAll(TaskList.ToArray());

Найкращий варіант, який я бачив, - це наступний метод розширення:

public static Task ForEachAsync<T>(this IEnumerable<T> sequence, Func<T, Task> action) {
    return Task.WhenAll(sequence.Select(action));
}

Назвіть це так:

await sequence.ForEachAsync(item => item.SomethingAsync(blah));

Або з лямбда-асинхрією:

await sequence.ForEachAsync(async item => {
    var more = await GetMoreAsync(item);
    await more.FrobbleAsync();
});

Ви можете скористатися WhenAllфункцією, яка поверне очікуваний Taskабо WaitAllякий не має типу повернення, і заблокує подальше виконання коду синхронізовано до Thread.Sleepтих пір, поки всі завдання не будуть виконані, скасовані або не виконані помилки.

Приклад

var tasks = new Task[] {
    TaskOperationOne(),
    TaskOperationTwo()
};

Task.WaitAll(tasks);
// or
await Task.WhenAll(tasks);

Якщо ви хочете виконати завдання в прямокутному порядку, ви можете отримати натхнення з цього прихильника.

Ви хочете зв'язати ланцюги Task, або їх можна викликати паралельно?

Для прикування
просто зробіть щось на кшталт

Task.Run(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);
Task.Factory.StartNew(...).ContinueWith(...).ContinueWith(...).ContinueWith(...);

і не забудьте перевірити попередній Taskекземпляр у кожному, ContinueWithоскільки це може бути несправним.

Для паралельного способу
Найпростіший метод, який я натрапив: Parallel.Invoke інакше є Task.WaitAllабо ви навіть можете використовувати WaitHandles для виконання відліку до нульових дій (зачекайте, є новий клас CountdownEvent:), або ...

Ось так я це роблю з масивом Func <> :

var tasks = new Func<Task>[]
{
   () => myAsyncWork1(),
   () => myAsyncWork2(),
   () => myAsyncWork3()
};

await Task.WhenAll(tasks.Select(task => task()).ToArray()); //Async    
Task.WaitAll(tasks.Select(task => task()).ToArray()); //Or use WaitAll for Sync

Ще одна відповідь ... але я зазвичай опиняюсь у випадку, коли мені потрібно одночасно завантажувати дані і вводити їх у змінні, наприклад:

var cats = new List<Cat>();
var dog = new Dog();

var loadDataTasks = new Task[]
{
    Task.Run(async () => cats = await LoadCatsAsync()),
    Task.Run(async () => dog = await LoadDogAsync())
};

try
{
    await Task.WhenAll(loadDataTasks);
}
catch (Exception ex)
{
    // handle exception
}

Я підготував фрагмент коду, щоб показати вам, як використовувати завдання для деяких із цих сценаріїв.

    // method to run tasks in a parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks) {

        await Task.WhenAll(tasks);
    }
    // methode to run task one by one 
    public async Task RunMultipleTaskOneByOne(Task[] tasks)
    {
        for (int i = 0; i < tasks.Length - 1; i++)
            await tasks[i];
    }
    // method to run i task in parallel 
    public async Task RunMultipleTaskParallel(Task[] tasks, int i)
    {
        var countTask = tasks.Length;
        var remainTasks = 0;
        do
        {
            int toTake = (countTask < i) ? countTask : i;
            var limitedTasks = tasks.Skip(remainTasks)
                                    .Take(toTake);
            remainTasks += toTake;
            await RunMultipleTaskParallel(limitedTasks.ToArray());
        } while (remainTasks < countTask);
    }