blocks|key|481694|text|因为你调用的API是异步的，所以Parallel.ForEach版本没有多大意义。你不应该在WaitAll版本中使用.Wait，因为这会失去并行性，如果调用者是异步的，另一个选择是在执行Select和ToArray之后使用Task.WhenAll来生成任务数组。第二种选择是使用Rx2.0|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|481695|entityMap^0|G|G|1A|7|1M|5|2L|6|2S|7|33|C|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|G|$]]

Since the API you're calling is async, the <code>Parallel.ForEach</code> version doesn't make much sense. You shouldnt use <code>.Wait</code> in the <code>WaitAll</code> version since that would lose the parallelism Another alternative if the caller is async is using <code>Task.WhenAll</code> after doing <code>Select</code> and <code>ToArray</code> to generate the array of tasks. A second alternative is using Rx 2.0

blocks|key|481743|text|我很想看看问题中提供的方法的结果以及被接受的答案，所以我把它放在了测试中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|481744|代码如下：|481745|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Threading;
using+System.Threading.Tasks;

namespace+AsyncTest
{
++++class+Program
++++{
++++++++class+Worker
++++++++{
++++++++++++public+int+Id;
++++++++++++public+int+SleepTimeout;

++++++++++++public+async+Task+DoWork(DateTime+testStart)
++++++++++++{
++++++++++++++++var+workerStart+=+DateTime.Now;
++++++++++++++++Console.WriteLine("Worker+{0}+started+on+thread+{1},+beginning+{2}+seconds+after+test+start.",
++++++++++++++++++++Id,+Thread.CurrentThread.ManagedThreadId,+(workerStart-testStart).TotalSeconds.ToString("F2"));
++++++++++++++++await+Task.Run(()+=>+Thread.Sleep(SleepTimeout));
++++++++++++++++var+workerEnd+=+DateTime.Now;
++++++++++++++++Console.WriteLine("Worker+{0}+stopped;+the+worker+took+{1}+seconds,+and+it+finished+{2}+seconds+after+the+test+start.",
+++++++++++++++++++Id,+(workerEnd-workerStart).TotalSeconds.ToString("F2"),+(workerEnd-testStart).TotalSeconds.ToString("F2"));
++++++++++++}
++++++++}

++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++var+workers+=+new+List<Worker>
++++++++++++{
++++++++++++++++new+Worker+{+Id+=+1,+SleepTimeout+=+1000+},
++++++++++++++++new+Worker+{+Id+=+2,+SleepTimeout+=+2000+},
++++++++++++++++new+Worker+{+Id+=+3,+SleepTimeout+=+3000+},
++++++++++++++++new+Worker+{+Id+=+4,+SleepTimeout+=+4000+},
++++++++++++++++new+Worker+{+Id+=+5,+SleepTimeout+=+5000+},
++++++++++++};

++++++++++++var+startTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Starting+test:+Parallel.ForEach...");
++++++++++++PerformTest_ParallelForEach(workers,+startTime);
++++++++++++var+endTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Test+finished+after+{0}+seconds.\n",
++++++++++++++++(endTime+-+startTime).TotalSeconds.ToString("F2"));

++++++++++++startTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Starting+test:+Task.WaitAll...");
++++++++++++PerformTest_TaskWaitAll(workers,+startTime);
++++++++++++endTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Test+finished+after+{0}+seconds.\n",
++++++++++++++++(endTime+-+startTime).TotalSeconds.ToString("F2"));

++++++++++++startTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Starting+test:+Task.WhenAll...");
++++++++++++var+task+=+PerformTest_TaskWhenAll(workers,+startTime);
++++++++++++task.Wait();
++++++++++++endTime+=+DateTime.Now;
++++++++++++Console.WriteLine("Test+finished+after+{0}+seconds.\n",
++++++++++++++++(endTime+-+startTime).TotalSeconds.ToString("F2"));

++++++++++++Console.ReadKey();
++++++++}

++++++++static+void+PerformTest_ParallelForEach(List<Worker>+workers,+DateTime+testStart)
++++++++{
++++++++++++Parallel.ForEach(workers,+worker+=>+worker.DoWork(testStart).Wait());
++++++++}

++++++++static+void+PerformTest_TaskWaitAll(List<Worker>+workers,+DateTime+testStart)
++++++++{
++++++++++++Task.WaitAll(workers.Select(worker+=>+worker.DoWork(testStart)).ToArray());
++++++++}

++++++++static+Task+PerformTest_TaskWhenAll(List<Worker>+workers,+DateTime+testStart)
++++++++{
++++++++++++return+Task.WhenAll(workers.Select(worker+=>+worker.DoWork(testStart)));
++++++++}
++++}
}|code-block|syntax|javascript|481746|以及由此产生的输出：|481747|Starting+test:+Parallel.ForEach...
Worker+1+started+on+thread+1,+beginning+0.21+seconds+after+test+start.
Worker+4+started+on+thread+5,+beginning+0.21+seconds+after+test+start.
Worker+2+started+on+thread+3,+beginning+0.21+seconds+after+test+start.
Worker+5+started+on+thread+6,+beginning+0.21+seconds+after+test+start.
Worker+3+started+on+thread+4,+beginning+0.21+seconds+after+test+start.
Worker+1+stopped;+the+worker+took+1.90+seconds,+and+it+finished+2.11+seconds+after+the+test+start.
Worker+2+stopped;+the+worker+took+3.89+seconds,+and+it+finished+4.10+seconds+after+the+test+start.
Worker+3+stopped;+the+worker+took+5.89+seconds,+and+it+finished+6.10+seconds+after+the+test+start.
Worker+4+stopped;+the+worker+took+5.90+seconds,+and+it+finished+6.11+seconds+after+the+test+start.
Worker+5+stopped;+the+worker+took+8.89+seconds,+and+it+finished+9.10+seconds+after+the+test+start.
Test+finished+after+9.10+seconds.

Starting+test:+Task.WaitAll...
Worker+1+started+on+thread+1,+beginning+0.01+seconds+after+test+start.
Worker+2+started+on+thread+1,+beginning+0.01+seconds+after+test+start.
Worker+3+started+on+thread+1,+beginning+0.01+seconds+after+test+start.
Worker+4+started+on+thread+1,+beginning+0.01+seconds+after+test+start.
Worker+5+started+on+thread+1,+beginning+0.01+seconds+after+test+start.
Worker+1+stopped;+the+worker+took+1.00+seconds,+and+it+finished+1.01+seconds+after+the+test+start.
Worker+2+stopped;+the+worker+took+2.00+seconds,+and+it+finished+2.01+seconds+after+the+test+start.
Worker+3+stopped;+the+worker+took+3.00+seconds,+and+it+finished+3.01+seconds+after+the+test+start.
Worker+4+stopped;+the+worker+took+4.00+seconds,+and+it+finished+4.01+seconds+after+the+test+start.
Worker+5+stopped;+the+worker+took+5.00+seconds,+and+it+finished+5.01+seconds+after+the+test+start.
Test+finished+after+5.01+seconds.

Starting+test:+Task.WhenAll...
Worker+1+started+on+thread+1,+beginning+0.00+seconds+after+test+start.
Worker+2+started+on+thread+1,+beginning+0.00+seconds+after+test+start.
Worker+3+started+on+thread+1,+beginning+0.00+seconds+after+test+start.
Worker+4+started+on+thread+1,+beginning+0.00+seconds+after+test+start.
Worker+5+started+on+thread+1,+beginning+0.00+seconds+after+test+start.
Worker+1+stopped;+the+worker+took+1.00+seconds,+and+it+finished+1.00+seconds+after+the+test+start.
Worker+2+stopped;+the+worker+took+2.00+seconds,+and+it+finished+2.00+seconds+after+the+test+start.
Worker+3+stopped;+the+worker+took+3.00+seconds,+and+it+finished+3.00+seconds+after+the+test+start.
Worker+4+stopped;+the+worker+took+4.00+seconds,+and+it+finished+4.00+seconds+after+the+test+start.
Worker+5+stopped;+the+worker+took+5.00+seconds,+and+it+finished+5.00+seconds+after+the+test+start.
Test+finished+after+5.00+seconds.|481748|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I was curious to see the results of the methods provided in the question as well as the accepted answer, so I put it to the test.

Here's the code:

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncTest
{
 class Program
 {
 class Worker
 {
 public int Id;
 public int SleepTimeout;

 public async Task DoWork(DateTime testStart)
 {
 var workerStart = DateTime.Now;
 Console.WriteLine("Worker {0} started on thread {1}, beginning {2} seconds after test start.",
 Id, Thread.CurrentThread.ManagedThreadId, (workerStart-testStart).TotalSeconds.ToString("F2"));
 await Task.Run(() =&gt; Thread.Sleep(SleepTimeout));
 var workerEnd = DateTime.Now;
 Console.WriteLine("Worker {0} stopped; the worker took {1} seconds, and it finished {2} seconds after the test start.",
 Id, (workerEnd-workerStart).TotalSeconds.ToString("F2"), (workerEnd-testStart).TotalSeconds.ToString("F2"));
 }
 }

 static void Main(string[] args)
 {
 var workers = new List&lt;Worker&gt;
 {
 new Worker { Id = 1, SleepTimeout = 1000 },
 new Worker { Id = 2, SleepTimeout = 2000 },
 new Worker { Id = 3, SleepTimeout = 3000 },
 new Worker { Id = 4, SleepTimeout = 4000 },
 new Worker { Id = 5, SleepTimeout = 5000 },
 };

 var startTime = DateTime.Now;
 Console.WriteLine("Starting test: Parallel.ForEach...");
 PerformTest_ParallelForEach(workers, startTime);
 var endTime = DateTime.Now;
 Console.WriteLine("Test finished after {0} seconds.\n",
 (endTime - startTime).TotalSeconds.ToString("F2"));

 startTime = DateTime.Now;
 Console.WriteLine("Starting test: Task.WaitAll...");
 PerformTest_TaskWaitAll(workers, startTime);
 endTime = DateTime.Now;
 Console.WriteLine("Test finished after {0} seconds.\n",
 (endTime - startTime).TotalSeconds.ToString("F2"));

 startTime = DateTime.Now;
 Console.WriteLine("Starting test: Task.WhenAll...");
 var task = PerformTest_TaskWhenAll(workers, startTime);
 task.Wait();
 endTime = DateTime.Now;
 Console.WriteLine("Test finished after {0} seconds.\n",
 (endTime - startTime).TotalSeconds.ToString("F2"));

 Console.ReadKey();
 }

 static void PerformTest_ParallelForEach(List&lt;Worker&gt; workers, DateTime testStart)
 {
 Parallel.ForEach(workers, worker =&gt; worker.DoWork(testStart).Wait());
 }

 static void PerformTest_TaskWaitAll(List&lt;Worker&gt; workers, DateTime testStart)
 {
 Task.WaitAll(workers.Select(worker =&gt; worker.DoWork(testStart)).ToArray());
 }

 static Task PerformTest_TaskWhenAll(List&lt;Worker&gt; workers, DateTime testStart)
 {
 return Task.WhenAll(workers.Select(worker =&gt; worker.DoWork(testStart)));
 }
 }
}
</code></pre>

And the resulting output:

<pre><code>Starting test: Parallel.ForEach...
Worker 1 started on thread 1, beginning 0.21 seconds after test start.
Worker 4 started on thread 5, beginning 0.21 seconds after test start.
Worker 2 started on thread 3, beginning 0.21 seconds after test start.
Worker 5 started on thread 6, beginning 0.21 seconds after test start.
Worker 3 started on thread 4, beginning 0.21 seconds after test start.
Worker 1 stopped; the worker took 1.90 seconds, and it finished 2.11 seconds after the test start.
Worker 2 stopped; the worker took 3.89 seconds, and it finished 4.10 seconds after the test start.
Worker 3 stopped; the worker took 5.89 seconds, and it finished 6.10 seconds after the test start.
Worker 4 stopped; the worker took 5.90 seconds, and it finished 6.11 seconds after the test start.
Worker 5 stopped; the worker took 8.89 seconds, and it finished 9.10 seconds after the test start.
Test finished after 9.10 seconds.

Starting test: Task.WaitAll...
Worker 1 started on thread 1, beginning 0.01 seconds after test start.
Worker 2 started on thread 1, beginning 0.01 seconds after test start.
Worker 3 started on thread 1, beginning 0.01 seconds after test start.
Worker 4 started on thread 1, beginning 0.01 seconds after test start.
Worker 5 started on thread 1, beginning 0.01 seconds after test start.
Worker 1 stopped; the worker took 1.00 seconds, and it finished 1.01 seconds after the test start.
Worker 2 stopped; the worker took 2.00 seconds, and it finished 2.01 seconds after the test start.
Worker 3 stopped; the worker took 3.00 seconds, and it finished 3.01 seconds after the test start.
Worker 4 stopped; the worker took 4.00 seconds, and it finished 4.01 seconds after the test start.
Worker 5 stopped; the worker took 5.00 seconds, and it finished 5.01 seconds after the test start.
Test finished after 5.01 seconds.

Starting test: Task.WhenAll...
Worker 1 started on thread 1, beginning 0.00 seconds after test start.
Worker 2 started on thread 1, beginning 0.00 seconds after test start.
Worker 3 started on thread 1, beginning 0.00 seconds after test start.
Worker 4 started on thread 1, beginning 0.00 seconds after test start.
Worker 5 started on thread 1, beginning 0.00 seconds after test start.
Worker 1 stopped; the worker took 1.00 seconds, and it finished 1.00 seconds after the test start.
Worker 2 stopped; the worker took 2.00 seconds, and it finished 2.00 seconds after the test start.
Worker 3 stopped; the worker took 3.00 seconds, and it finished 3.00 seconds after the test start.
Worker 4 stopped; the worker took 4.00 seconds, and it finished 4.00 seconds after the test start.
Worker 5 stopped; the worker took 5.00 seconds, and it finished 5.00 seconds after the test start.
Test finished after 5.00 seconds.
</code></pre>

blocks|key|264825|text|here说，我只想补充上面所有的答案，如果你写了一个库，使用ConfigureAwait(false)是一个很好的实践，可以获得更好的性能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|264826|所以这段代码看起来更好：|264827|+public+static+async+Task+DoWork()+
+{
+++++int[]+ids+=+new[]+{+1,+2,+3,+4,+5+};
+++++await+Task.WhenAll(ids.Select(i+=>+DoSomething(1,+i))).ConfigureAwait(false);
+}|code-block|syntax|javascript|264828|完整的小提琴链接here。|264829|entityMap|0|LINK|mutability|MUTABLE|url|https://devblogs.microsoft.com/dotnet/configureawait-faq/|1|https://sharplab.io/#v2:CYLg1APgAgTAjAWAFBQAwAIpwKwG5lqZwB0AMgJYB2AjvijKgTAMzoDey6XmMM7n3QVgCcACgBEgHg3AIPviAlHUEBfAV1WZWWAGyYAHJh0ARAPYB1YwCcA1qLnp1HJIMFUALgG0AuunLAAzugAvOiUAKYA7l7s6HAANOgw8czxACzx2OhKis5cUMIGxKYAFqGUAIIANhWivn7EAMqhFaEAxq41QQB86Cb1xgC2oa5FVADmonE%2BctPEAMLGlABm5KMArhahZeEAhuTti9sVfqEK6ipO3OpQmnA6UPpQRsZ9g8NjNZSu6NvxbugARnIHOpBAA3bYWdDAIKYfKPYgAMQsAwASqE/KsKu1tmBAdkuOclEA=^0|U|L|0|4|0|0|0|0|8|4|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|O|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

I just want to add to all great answers above,
that if you write a library it's a good practice to use <code>ConfigureAwait(false)</code>
and get better performance, as said <a href="https://devblogs.microsoft.com/dotnet/configureawait-faq/" rel="nofollow noreferrer">here</a>.
So this snippet seems to be better:
<pre><code> public static async Task DoWork() 
 {
 int[] ids = new[] { 1, 2, 3, 4, 5 };
 await Task.WhenAll(ids.Select(i =&gt; DoSomething(1, i))).ConfigureAwait(false);
 }
</code></pre>
A full fiddle link <a href="https://sharplab.io/#v2:CYLg1APgAgTAjAWAFBQAwAIpwKwG5lqZwB0AMgJYB2AjvijKgTAMzoDey6XmMM7n3QVgCcACgBEgHg3AIPviAlHUEBfAV1WZWWAGyYAHJh0ARAPYB1YwCcA1qLnp1HJIMFUALgG0AuunLAAzugAvOiUAKYA7l7s6HAANOgw8czxACzx2OhKis5cUMIGxKYAFqGUAIIANhWivn7EAMqhFaEAxq41QQB86Cb1xgC2oa5FVADmonE+ctPEAMLGlABm5KMArhahZeEAhuTti9sVfqEK6ipO3OpQmnA6UPpQRsZ9g8NjNZSu6NvxbugARnIHOpBAA3bYWdDAIKYfKPYgAMQsAwASqE/KsKu1tmBAdkuOclEA=" rel="nofollow noreferrer">here</a>.

I'm using an API client that is completely asynchrounous, that is, each operation either returns <code>Task</code> or <code>Task&lt;T&gt;</code>, e.g:

<pre><code>static async Task DoSomething(int siteId, int postId, IBlogClient client)
{
 await client.DeletePost(siteId, postId); // call API client
 Console.WriteLine("Deleted post {0}.", siteId);
}
</code></pre>

Using the C# 5 async/await operators, what is the correct/most efficient way to start multiple tasks and wait for them all to complete:

<pre><code>int[] ids = new[] { 1, 2, 3, 4, 5 };
Parallel.ForEach(ids, i =&gt; DoSomething(1, i, blogClient).Wait());
</code></pre>

or:

<pre><code>int[] ids = new[] { 1, 2, 3, 4, 5 };
Task.WaitAll(ids.Select(i =&gt; DoSomething(1, i, blogClient)).ToArray());
</code></pre>

Since the API client is using HttpClient internally, I would expect this to issue 5 HTTP requests immediately, writing to the console as each one completes.

Using async/await for multiple tasks

我使用的API客户端是完全异步的，也就是说，每个操作要么返回Task，要么返回Task<T>，例如：static async Task DoSomething(int siteId, int postId, IBlogClient client){ await client.DeletePost(siteId, ...

问对多个任务使用异步/等待
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对多个任务使用异步/等待EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对多个任务使用异步/等待
EN