Parallel vs Await vs Result - which one is better for deferred execution

Question

Implementation #1 - using Parallel loop

var client = new HttpClient();
var processes = new List<Task<object>>();

Parallel.ForEach(urls, url =>
{
  processes.Add(client.GetAsync(url).Result.Content.ReadAsAsync<object>());
});

Task.WhenAll(processes);

Implementation #2 - using async method + Result

var client = new HttpClient();
var processes = new List<Task<object>>();

urls.ForEach(url =>
{
  processes.Add(GetChain(client, url));
});

Task.WhenAll(processes);

async Task<object> GetChain(HttpClient client, string url)
{
  return await client.GetAsync(url).Result.Content.ReadAsAsync<object>();
}

Implementation #3 - using async method + await

var client = new HttpClient();
var processes = new List<Task<object>>();

urls.ForEach(url =>
{
  processes.Add(GetChain(client, url));
});

Task.WhenAll(processes);

async Task<object> GetChain(HttpClient client, string url)
{
  var chain = await client.GetAsync(url);
  return await chain.Content.ReadAsAsync<object>();
}

I like implementation #1 with Parallel loop, but there is a possibility that Parallel will create a new thread on each iteration and will consume more resources.

Questions

Is there a difference between these methods, can I keep using Parallel.ForEach?
If Parallel loop is bad, how can I improve it without creating a separate "async" method?
Is "await method.Result" the same as "await method1 await method2", #2 vs #3?

P.S. There are two "await" calls because HttpClient requests data, then read it asynchronously.

Extra question - are these lines the same?

method1.Result.method2                             // get result immediately
method1.ContinueWith(data => data.Result.method2)  // call both methods first

It's only usefull to use the Parallel.foreach if you some heavy operation to execute parallel. Adding items to a list isn't heavy. It's not usefull to mix async and parallel. — Jeroen van Langen, Aug 30 '18 at 07:04
The first one (Parallel.ForEach()) just adds a useless level of parallelism. Filling the Tasks should be lightweight and fast. — bommelding, Aug 30 '18 at 07:06
Extra: Not the same. But a continuation is what you probably want, I'd have guessed. — Fildor, Aug 30 '18 at 07:07
The .Result in example 2 kills one branch of async/await, it could even lead to a deadlock. — bommelding, Aug 30 '18 at 07:07
Perfect example for [code review](https://codereview.stackexchange.com/) You should post it there. — Jeroen van Langen, Aug 30 '18 at 07:10
Also `List` is not thread safe an can not be used like in Example 1. — Magnus, Aug 31 '18 at 06:06

Z.R.T. · Accepted Answer · 2018-09-01T15:21:48.320

consider the following example . it helps your to find answer on your question:

private static readonly List<Uri> Urls = new List<Uri>() {
    new Uri(""),
    new Uri("") };
....
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var result1 = Urls.Select(GetContent).ToArray();
stopwatch.Stop();
Console.WriteLine($@"Synchronous and NOT In Parallel:{stopwatch.ElapsedMilliseconds}");

stopwatch.Restart();
var result2 = Urls.AsParallel().Select(GetContent).ToArray();
stopwatch.Stop();
Console.WriteLine($@"Synchronous and In Parallel:{stopwatch.ElapsedMilliseconds}");

stopwatch.Restart();
var task1 = DoAsyncNotParallel();
task1.Wait();
stopwatch.Stop();
Console.WriteLine($@"Asynchronous and NOT In Parallel:{stopwatch.ElapsedMilliseconds}");

stopwatch.Restart();
var task2 = DoAsyncInParallel();
task2.Wait();
stopwatch.Stop();
Console.WriteLine($@"Asynchronous and In Parallel:{stopwatch.ElapsedMilliseconds}");

static async Task<string[]> DoAsyncNotParallel()
{
    List<string> content = new List<string>();
    foreach (var uri in Urls)
    {
        content.Add(await GetContentAsync(uri));
    }

    return content.ToArray();
}

static async Task<string[]> DoAsyncInParallel()
{
    var tasks = Urls.Select(uri => GetContentAsync(uri));

    var content = await Task.WhenAll(tasks);

    return content;
}
private static async Task<string> GetContentAsync(Uri uri)
{
    HttpClient httpClient = new HttpClient();
    var response = await httpClient.GetAsync(uri);
    var content = await response.Content.ReadAsStringAsync();
    return content;
}


private static string GetContent(Uri uri)
{
    HttpClient httpClient = new HttpClient();
    var response = httpClient.GetAsync(uri).Result;
    var content = response.Content.ReadAsStringAsync().Result;
    return content;
}

i recommend you to look through the following links which can be useful for you :

Async Programming : Introduction to Async/Await on ASP.NET, by Stephen Cleary
How and Where Concurrent Asynchronous I/O with ASP.NET Web API, by Tugberk Ugurlu
Parallel Programming with .NET, from Microsoft

about last part of question:

method1.Result.method2();

calling thread is blocked until method1 is completed, then method2 is being called

method1.ContinueWith(data => data.Result.method2());

calling thread is not blocked, method1 is being executed asynchronously . once method1 is completed, then new Task is running like Task.Run(()=>{ method1.Result.method2()}). in this case method1.Result doesn't block calling thread because method1 alread completed, isCompleted=true

Parallel vs Await vs Result - which one is better for deferred execution

1 Answers1