लूप में वेट का उपयोग कैसे करें

Question 1

मैं एक अतुल्यकालिक कंसोल ऐप बनाने की कोशिश कर रहा हूं जो एक संग्रह पर कुछ काम करता है। मेरे पास एक संस्करण है जो लूप के लिए समानांतर का उपयोग करता है एक और संस्करण जो एसिंक्स / वेट का उपयोग करता है। मुझे उम्मीद है कि समान्तर / प्रतीक्षित संस्करण समानांतर संस्करण के समान काम करेगा लेकिन यह समकालिक रूप से निष्पादित होता है। मैं क्या गलत कर रहा हूं?

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

Question 2

जिस तरह से आप awaitकीवर्ड का उपयोग कर रहे हैं वह C # को बताता है कि आप हर बार लूप से गुजरने का इंतजार करना चाहते हैं, जो समानांतर नहीं है। आप अपनी पद्धति को इस तरह से फिर से लिख सकते हैं कि आप क्या चाहते हैं, Taskएस की सूची को संग्रहीत करके और फिर 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);
}

Question 3

awaitअगली पुनरावृत्ति शुरू करने से पहले आपका कोड प्रत्येक ऑपरेशन (उपयोग करने ) का इंतजार करता है ।
इसलिए, आपको कोई समानता नहीं मिलती है।

यदि आप समानांतर में एक मौजूदा अतुल्यकालिक ऑपरेशन चलाना चाहते हैं, तो आपको ज़रूरत नहीं है await; आपको बस एक संग्रह प्राप्त करने की आवश्यकता है Taskऔर Task.WhenAll()उन सभी के लिए प्रतीक्षा करने वाले कार्य को वापस करने के लिए कॉल करें:

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

Question 4

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

Question 5

C # 7.0 में, आप प्रत्येक सदस्य के नाम का उपयोग कर सकते हैं , यहाँ नया वाक्यविन्यास का उपयोग करते हुए टिम एस का उत्तर दिया गया है:

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