Today, I need to complete an interesting test to demonstrate my knowledge of asynchronous programming by creating a method that downloads three resources and aggregates the content length of all 3 responses.
The first idea ran to my mind is Task.WhenAll:
static async Task<long> FetchContentLengthWaitAllAsync(Uri[] urls, CancellationToken cancellationToken)
{
// Start a Stopwatch to evaluate performance
var sw = new Stopwatch();
sw.Start();
// Current thread id
Console.WriteLine("Current Thread Id: " + Thread.CurrentThread.ManagedThreadId);
// Request
var contentLength = (await Task.WhenAll(urls.Select(url =>
{
// Web client for the request
using (var wc = new WebClient())
{
// Cancellation on the token will cancel the request
cancellationToken.Register(() =>
{
wc.CancelAsync();
Console.WriteLine($"Request cancelled!");
});
wc.DownloadDataCompleted += (s, e) =>
{
Console.WriteLine("FetchContentLengthWaitAllAsync Thread Id: " + Thread.CurrentThread.ManagedThreadId);
};
// θΏε
return wc.DownloadDataTaskAsync(url);
}
}))).Sum(bytes => bytes.Length);
// Output
sw.Stop();
Console.WriteLine("FetchContentLengthDirectAsync Miliseconds: " + sw.ElapsedMilliseconds);
// Return
return contentLength;
}
I studied further and learned several posts like 'Concurrency vs. Parallel vs. Async in .NET' (https://dev.to/scotthannen/concurrency-vs-parallel-vs-async-in-net-3812) and 'Parallel Foreach async in C#' (https://medium.com/@alex.puiu/parallel-foreach-async-in-c-36756f8ebe62). They put me in vague than before. Just hands-on:
static async Task<long> FetchContentLengthAsync(Uri[] urls, CancellationToken cancellationToken)
{
// Start a Stopwatch to evaluate performance
var sw = new Stopwatch();
sw.Start();
// Request
var resultCollection = new ConcurrentBag<long>();
await Task.Run(() =>
{
Parallel.ForEach(urls, (url) =>
{
// Web client for the request
using (var wc = new WebClient())
{
// Cancellation on the token will cancel the request
cancellationToken.Register(() =>
{
wc.CancelAsync();
Console.WriteLine($"Request cancelled!");
});
// θΏε
resultCollection.Add(wc.DownloadData(url).Length);
Console.WriteLine("FetchContentLengthAsync Thread Id: " + Thread.CurrentThread.ManagedThreadId);
}
});
});
// Output
sw.Stop();
Console.WriteLine("FetchContentLengthAsync Miliseconds: " + sw.ElapsedMilliseconds);
// Return
return resultCollection.Sum();
}
What are the differences? I implemented a test:
static async Task Main(string[] args)
{
// Requested URLs
var urls = new Uri[] { new Uri("https://dev.to/garryxiao/react-typescript-electron-all-steps-to-start-lcc"), new Uri("https://dev.to/bipinrajbhar/the-beginner-s-guide-to-react-introduction-50i0"), new Uri("https://stackoverflow.com/questions/22024233/read-response-header-from-webclient-in-c-sharp") };
// Cancellation token source
using (var cts = new CancellationTokenSource())
{
// WaitAll way
var contentLengthWaitAll = await FetchContentLengthWaitAllAsync(urls, cts.Token);
// Common
var contentLengthCommon = await FetchContentLengthAsync(urls, cts.Token);
}
}
And here was the result:
Conclusions:
- Parallel.ForEach is quicker than Task.WhenAll. Parallel itself is synchronous.
- Parallel.ForEach is multiple threads solution while Task.WhenAll will probably share threads. If tasks share the same thread, they are just pieces of the thread and will need more time to complete the tasks.
- Because they are both concurrencies, so keep an eye on thread-safe issues.
- async/await are kinds of syntactic sugar that enables concurrency potential but not necessarily multithreading.
For more details: https://www.codemag.com/Article/1211071/Tasks-and-Parallelism-The-New-Wave-of-Multithreading
Top comments (5)
I think it's not a good example !
Parallelism should be used on CPU bound senarios not IO bound.
This is a good article and I think this explanation deserve more exposure.
I'm a beginner in
C#. To help more beginner, I have made a simpler working example with source code in github.π· epsi.bitbucket.io/lambda/2020/12/2...
First the process sender and receiver
And then run both
I hope this could help other who seeks for other case example.
ππ½
Thank you for posting about concurrency.
Hi Garry, what about using async within Parallel.ForEach, like Parallel.ForEach(items, async (item) => {})? Does it make sense? My case is as follows: I am getting list of data from DB. Then, using Parallel.ForEach I'm checking the child entities - images. If each of image has FilePath - in our case it means the image is stored in file system and I need to read image data from stream into Image entity (byte[]). I'm using the above approach, but don't know if it has some dangerous pitfalls.
Hi Alexandis, in the production environment, there are three points I would mention:
There are certain drawbacks I can see with this: