Menjalankan beberapa tugas async dan menunggu semuanya selesai

Saya perlu menjalankan beberapa tugas async di aplikasi konsol, dan menunggu semuanya selesai sebelum diproses lebih lanjut.

Ada banyak artikel di luar sana, tetapi saya tampaknya semakin bingung semakin saya membaca. Saya telah membaca dan memahami prinsip-prinsip dasar pustaka Tugas, tapi saya jelas kehilangan tautan di suatu tempat.

Saya mengerti bahwa mungkin untuk melakukan tugas-tugas rantai sehingga mereka mulai setelah selesai lainnya (yang merupakan skenario untuk semua artikel yang saya baca), tapi saya ingin semua Tugas saya berjalan pada waktu yang sama, dan saya ingin tahu sekali mereka semua selesai.

Apa implementasi paling sederhana untuk skenario seperti ini?

Kedua jawaban tidak menyebutkan yang ditunggu-tunggu Task.WhenAll:

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

await Task.WhenAll(task1, task2);

Perbedaan utama antara Task.WaitAlldan Task.WhenAlladalah bahwa yang pertama akan memblokir (mirip dengan menggunakan Waitpada satu tugas) sedangkan yang terakhir tidak akan dan dapat ditunggu, menghasilkan kontrol kembali ke pemanggil sampai semua tugas selesai.

Lebih dari itu, penanganan pengecualian berbeda:

Task.WaitAll:

Setidaknya satu instance Task dibatalkan - atau pengecualian dilemparkan selama eksekusi setidaknya satu instance Task. Jika tugas dibatalkan, AggregateException berisi OperationCanceledException dalam koleksi InnerExceptions-nya.

Task.WhenAll:

Jika salah satu dari tugas yang disediakan menyelesaikan dalam kondisi yang salah, tugas yang dikembalikan juga akan selesai dalam keadaan yang salah, di mana pengecualiannya akan berisi agregasi dari set pengecualian yang terbuka dari masing-masing tugas yang disediakan.

Jika tidak ada tugas yang diberikan salah tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir pada status Dibatalkan.

Jika tidak ada tugas yang salah dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir pada status RanToCompletion. Jika array / enumerable yang disediakan tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil.

Anda dapat membuat banyak tugas seperti:

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

Task.WaitAll(TaskList.ToArray());

Pilihan terbaik yang pernah saya lihat adalah metode ekstensi berikut:

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

Sebut saja seperti ini:

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

Atau dengan lambda async:

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

Anda dapat menggunakan WhenAllyang akan mengembalikan yang ditunggu-tunggu Taskatau WaitAllyang tidak memiliki tipe pengembalian dan akan memblokir eksekusi kode lebih lanjut secara simultan Thread.Sleepsampai semua tugas selesai, dibatalkan atau salah.

Contoh

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

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

Jika Anda ingin menjalankan tugas dalam urutan praticular, Anda bisa mendapatkan inspirasi dari server ini .

Apakah Anda ingin rantai Tasks, atau mereka dapat dipanggil secara paralel?

Untuk merantai
Lakukan saja sesuatu seperti

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

dan jangan lupa untuk memeriksa Taskcontoh sebelumnya di masing ContinueWith- masing karena mungkin salah.

Untuk cara paralel
Metode paling sederhana yang saya temui: Parallel.Invoke Kalau tidak ada Task.WaitAllatau Anda bahkan dapat menggunakan WaitHandles untuk melakukan hitung mundur ke nol tindakan yang tersisa (tunggu, ada kelas baru:) CountdownEvent, atau ...

Ini adalah bagaimana saya melakukannya dengan Fungsi array <> :

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

Namun jawaban lain ... tapi saya biasanya menemukan diri saya dalam sebuah kasus, ketika saya perlu memuat data secara bersamaan dan memasukkannya ke dalam variabel, seperti:

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
}

Saya menyiapkan sepotong kode untuk menunjukkan kepada Anda bagaimana menggunakan tugas untuk beberapa skenario ini.

    // 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);
    }