Chạy nhiều tác vụ không đồng bộ và chờ tất cả hoàn thành

Tôi cần chạy nhiều tác vụ không đồng bộ trong ứng dụng bảng điều khiển và đợi tất cả hoàn thành trước khi xử lý thêm.

Có nhiều bài viết ngoài kia, nhưng tôi dường như càng bối rối hơn khi đọc. Tôi đã đọc và hiểu các nguyên tắc cơ bản của thư viện Tác vụ, nhưng rõ ràng tôi đang thiếu một liên kết ở đâu đó.

Tôi hiểu rằng có thể xâu chuỗi các nhiệm vụ để chúng bắt đầu sau khi hoàn thành một nhiệm vụ khác (đó là kịch bản cho tất cả các bài viết tôi đã đọc), nhưng tôi muốn tất cả các Nhiệm vụ của mình chạy cùng một lúc và tôi muốn biết một lần tất cả đã hoàn thành

Cách thực hiện đơn giản nhất cho một kịch bản như thế này là gì?

Cả hai câu trả lời đều không đề cập đến sự chờ đợi Task.WhenAll:

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

await Task.WhenAll(task1, task2);

Sự khác biệt chính giữa Task.WaitAllvà Task.WhenAlllà cái trước sẽ chặn (tương tự như sử dụng Waittrên một tác vụ) trong khi cái sau sẽ không và có thể được chờ đợi, mang lại quyền điều khiển cho người gọi cho đến khi tất cả các tác vụ kết thúc.

Hơn nữa, xử lý ngoại lệ khác nhau:

Task.WaitAll:

Ít nhất một trong số các trường hợp Nhiệm vụ đã bị hủy - hoặc một ngoại lệ đã được đưa ra trong quá trình thực thi ít nhất một trong các trường hợp Nhiệm vụ. Nếu một tác vụ đã bị hủy, AggregateException sẽ chứa một Activity HủyedException trong bộ sưu tập InternalExceptions của nó.

Task.WhenAll:

Nếu bất kỳ tác vụ được cung cấp nào hoàn thành ở trạng thái bị lỗi, thì tác vụ được trả lại cũng sẽ hoàn thành ở trạng thái Bị lỗi, trong đó các ngoại lệ của nó sẽ chứa tập hợp các ngoại lệ không được bao bọc từ mỗi tác vụ được cung cấp.

Nếu không có tác vụ được cung cấp nào bị lỗi nhưng ít nhất một trong số chúng đã bị hủy, tác vụ được trả lại sẽ kết thúc ở trạng thái Đã hủy.

Nếu không có tác vụ nào bị lỗi và không có tác vụ nào bị hủy, tác vụ kết quả sẽ kết thúc ở trạng thái RanToCompletion. Nếu mảng / liệt kê được cung cấp không chứa tác vụ, tác vụ được trả về sẽ ngay lập tức chuyển sang trạng thái RanToCompletion trước khi nó được trả về cho người gọi.

Bạn có thể tạo nhiều tác vụ như:

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

Task.WaitAll(TaskList.ToArray());

Tùy chọn tốt nhất tôi từng thấy là phương pháp mở rộng sau:

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

Gọi nó như thế này:

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

Hoặc với lambda async:

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

Bạn có thể sử dụng WhenAllcái nào sẽ trả về một cái đang chờ Taskhoặc WaitAllkhông có kiểu trả về và sẽ chặn mô hình thực thi mã tiếp theo Thread.Sleepcho đến khi tất cả các tác vụ được hoàn thành, hủy bỏ hoặc bị lỗi.

Thí dụ

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

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

Nếu bạn muốn chạy các nhiệm vụ theo thứ tự praticular, bạn có thể lấy cảm hứng từ anwser này .

Bạn có muốn xâu chuỗi các Tasks, hoặc chúng có thể được gọi theo cách song song không?

Để xích
Chỉ cần làm một cái gì đó như

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

và đừng quên kiểm tra Taskví dụ trước trong mỗi trường hợp ContinueWithvì nó có thể bị lỗi.

Đối với cách thức song song
Phương pháp đơn giản nhất mà tôi đã gặp: Parallel.Invoke Nếu không thì cóTask.WaitAll hoặc thậm chí bạn có thể sử dụng WaitHandles để thực hiện đếm ngược đến 0 hành động còn lại (chờ, có một lớp mới CountdownEvent:) hoặc ...

Đây là cách tôi thực hiện với một mảng 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

Còn một câu trả lời nữa ... nhưng tôi thường thấy mình trong một trường hợp, khi tôi cần tải dữ liệu đồng thời và đưa nó vào các biến, như:

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
}

Tôi đã chuẩn bị một đoạn mã để chỉ cho bạn cách sử dụng tác vụ cho một số tình huống này.

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