ใช้งาน async หลายงานและรอให้การดำเนินการทั้งหมดเสร็จสมบูรณ์

ฉันต้องเรียกใช้งาน async หลายรายการในแอปพลิเคชันคอนโซลและรอให้งานทั้งหมดดำเนินการจนเสร็จสิ้น

มีบทความมากมายที่นั่น แต่ฉันดูเหมือนจะสับสนมากยิ่งฉันอ่าน ฉันได้อ่านและทำความเข้าใจหลักการพื้นฐานของ Task Library แล้ว แต่ฉันขาดการเชื่อมโยงอย่างชัดเจน

ฉันเข้าใจว่าเป็นไปได้ที่จะเชื่อมโยงงานเพื่อให้พวกเขาเริ่มต้นหลังจากเสร็จสมบูรณ์ (ซึ่งเป็นสถานการณ์ที่ค่อนข้างมากสำหรับบทความทั้งหมดที่ฉันได้อ่าน) แต่ฉันต้องการให้งานทั้งหมดของฉันทำงานพร้อมกันและฉันอยากรู้อีกครั้ง เสร็จสิ้นทั้งหมด

การใช้งานที่ง่ายที่สุดสำหรับสถานการณ์เช่นนี้คืออะไร

คำตอบทั้งสองไม่ได้กล่าวถึงสิ่งที่รอคอยได้Task.WhenAll:

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

await Task.WhenAll(task1, task2);

ความแตกต่างที่สำคัญระหว่างTask.WaitAllและTask.WhenAllคือการที่อดีตจะปิดกั้น (คล้ายกับการใช้Waitในงานเดียว) ในขณะที่คนหลังจะไม่และสามารถรอได้ให้การควบคุมกลับไปที่ผู้โทรจนกว่างานทั้งหมดจะเสร็จสิ้น

ยิ่งกว่านั้นการจัดการข้อยกเว้นต่างกัน:

Task.WaitAll:

อย่างน้อยหนึ่งในอินสแตนซ์ของงานถูกยกเลิกหรือมีข้อผิดพลาดเกิดขึ้นระหว่างการดำเนินการของอินสแตนซ์ของงานอย่างน้อยหนึ่งรายการ หากงานถูกยกเลิก AggregateException มี OperationCanceledException ในคอลเล็กชัน InnerExceptions

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

หรือด้วยแลมบ์ดา async:

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

หากคุณต้องการที่จะเรียกใช้งานในลำดับ praticular คุณจะได้รับแรงบันดาลใจในรูปแบบนี้ Anwser

คุณต้องการที่จะเชื่อมโยงTasks หรือไม่พวกเขาสามารถเรียกในลักษณะคู่ขนาน?

สำหรับการผูกมัด
เพียงทำบางสิ่งเช่น

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