วิธีใช้รอวนซ้ำ

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

class Program
{
    static void Main(string[] args)
    {
        var worker = new Worker();
        worker.ParallelInit();
        var t = worker.Init();
        t.Wait();
        Console.ReadKey();
    }
}

public class Worker
{
    public async Task<bool> Init()
    {
        var series = Enumerable.Range(1, 5).ToList();
        foreach (var i in series)
        {
            Console.WriteLine("Starting Process {0}", i);
            var result = await DoWorkAsync(i);
            if (result)
            {
                Console.WriteLine("Ending Process {0}", i);
            }
        }

        return true;
    }

    public async Task<bool> DoWorkAsync(int i)
    {
        Console.WriteLine("working..{0}", i);
        await Task.Delay(1000);
        return true;
    }

    public bool ParallelInit()
    {
        var series = Enumerable.Range(1, 5).ToList();
        Parallel.ForEach(series, i =>
        {
            Console.WriteLine("Starting Process {0}", i);
            DoWorkAsync(i);
            Console.WriteLine("Ending Process {0}", i);
        });
        return true;
    }
}

วิธีที่คุณใช้awaitคีย์เวิร์ดจะบอก C # ว่าคุณต้องการรอทุกครั้งที่คุณผ่านลูปซึ่งไม่ขนานกัน คุณสามารถเขียนวิธีการของคุณใหม่เช่นนี้เพื่อทำสิ่งที่คุณต้องการโดยการจัดเก็บรายการTasks แล้วawaitรวมเข้าด้วยTask.WhenAllกัน

public async Task<bool> Init()
{
    var series = Enumerable.Range(1, 5).ToList();
    var tasks = new List<Task<Tuple<int, bool>>>();
    foreach (var i in series)
    {
        Console.WriteLine("Starting Process {0}", i);
        tasks.Add(DoWorkAsync(i));
    }
    foreach (var task in await Task.WhenAll(tasks))
    {
        if (task.Item2)
        {
            Console.WriteLine("Ending Process {0}", task.Item1);
        }
    }
    return true;
}

public async Task<Tuple<int, bool>> DoWorkAsync(int i)
{
    Console.WriteLine("working..{0}", i);
    await Task.Delay(1000);
    return Tuple.Create(i, true);
}

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

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

return Task.WhenAll(list.Select(DoWorkAsync));

public async Task<bool> Init()
{
    var series = Enumerable.Range(1, 5);
    Task.WhenAll(series.Select(i => DoWorkAsync(i)));
    return true;
}

ใน C # 7.0 คุณสามารถใช้ชื่อทางความหมายกับสมาชิกแต่ละคนของทูเปิลนี่คือคำตอบของTim S.โดยใช้ไวยากรณ์ใหม่:

public async Task<bool> Init()
{
    var series = Enumerable.Range(1, 5).ToList();
    var tasks = new List<Task<(int Index, bool IsDone)>>();

    foreach (var i in series)
    {
        Console.WriteLine("Starting Process {0}", i);
        tasks.Add(DoWorkAsync(i));
    }

    foreach (var task in await Task.WhenAll(tasks))
    {
        if (task.IsDone)
        {
            Console.WriteLine("Ending Process {0}", task.Index);
        }
    }

    return true;
}

public async Task<(int Index, bool IsDone)> DoWorkAsync(int i)
{
    Console.WriteLine("working..{0}", i);
    await Task.Delay(1000);
    return (i, true);
}

คุณยังสามารถกำจัดtask. ภายในforeach :

// ...
foreach (var (IsDone, Index) in await Task.WhenAll(tasks))
{
    if (IsDone)
    {
        Console.WriteLine("Ending Process {0}", Index);
    }
}
// ...