How to best run two async tasks in parallel and wait for the returned results of both?

Question

I'm looking for a simple C# example of a pattern that meets the following requirements:

1. I want to execute 2 methods asynchronously, initiating the second without waiting for the first to finish.
2. Each method accepts a parameter and returns and output value.
3. I then want to wait for the results of both before moving on.

This seemed like a scenario where I could easily use the async and await keywords but after looking at a couple of Hello World examples, I was surprised that I could not easily meet all of the above criteria at the same time. For example, while using the await keyword kept my UI from being non blocking and allowing my app to continue to be responsive to events while I await the completion of a method, the methods were still executing synchronously. Or if I was able to execute asynchronously, I had trouble trying to pass an input parameter to the calling method and receiving a result back.

The following seems to meet my requirements and leads me to believe that I'd be able to make great use out of it but first I'd like to get your feedback on how it can be improved.

I've played around with Threads before and found that make my code much more complex and was expecting that the "async and await" keywords would make my life easier but the following code which appears to meet my requirements does not even use these keywords. Am I using the "Parallel Task Library" here? If so, how would you contrast the functionality in this library to the async and await functionality?

using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ASyncCourse
{
    static class Program
    {
        static void Main()
        {
            int result1 = 0;
            int result2 = 0;

            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();

            Task task1 = Task.Run(() => result1 = DoSomeWork(1));
            Debug.WriteLine($"After Task1: {stopWatch.Elapsed}");

            Task task2 = Task.Run(() => result2 = DoSomeOtherWork(10));
            Debug.WriteLine($"After Task2: {stopWatch.Elapsed}");

            Task.WaitAll(task1, task2);
            stopWatch.Stop();

            int sum;
            
            sum = result1 + result2; 
            Debug.WriteLine($"Sum: {sum}");
            Debug.WriteLine($"Final: {stopWatch.Elapsed}");
        }

        private static int DoSomeOtherWork(int waitFor)
        {
            Thread.Sleep(waitFor * 1000);
            return waitFor;
        }

        private static int DoSomeWork(int waitFor)
        {
            Thread.Sleep(waitFor * 1000);
            return waitFor;
        }
    }
}

Answer 1

You can use the async and await pattern and await the cpu bound tasks, however you will need to use async Task Main() entry point

public static async Task Main()
{
    var task1 = Task.Run(() => CpuWork1(1));
    var task2 = Task.Run(() => CpuWork2(10));
    
    var result1 = await task1;
    var result2 = await task2;

    // or

    var results = await Task.WhenAll(task1, task2) ;
}

If your workloads are IO bound, then they would have the async Task<T> signature, and you would just await the methods returned tasks, similar to above (and not use Task.Run)

Complete Example

static async Task Main()
{

   var stopWatch = new Stopwatch();
   stopWatch.Start();

   var task1 = Task.Run(() =>  DoSomeWork(1));
   var task2 = Task.Run(() =>  DoSomeOtherWork(10));

   var results = await Task.WhenAll(task1, task2);
   stopWatch.Stop();

   Debug.WriteLine($"Sum: {results.Sum()}");
   Debug.WriteLine($"Final: {stopWatch.Elapsed}");
}

Or similarly with an async methods

static async Task Main()
{

   var stopWatch = new Stopwatch();
   stopWatch.Start();

   var task1 = DoSomeWorkAsync(1);
   var task2 = DoSomeOtherWorkAsync(10);

   var results = await Task.WhenAll(task1, task2);
   stopWatch.Stop();

   Debug.WriteLine($"Sum: {results.Sum()}");
   Debug.WriteLine($"Final: {stopWatch.Elapsed}");
}

private static async Task<int> DoSomeOtherWorkAsync(int waitFor)
{
   // some IO bound workload
   await Task.Delay(waitFor * 1000);
   return waitFor;
}

private static async Task<int> DoSomeWorkAsync(int waitFor)
{
   // some IO bound workload
   await Task.Delay(waitFor * 1000);
   return waitFor;
}

Answer 2

Asynchronous methods are method designed to access external resources without blocking and without wasting resources(extra threads)

Use Task.Delay(1000) to simulate asynchronous method.

private async Task<int> LoadSomething(int value)
{
    await Task.Delay(value * 1000);
    return value;
}

Then

var task1 = LoadSomething(2); 
// executes next line without waiting for previous line to complete
var task2 = LoadSomething(5); 

await Task.WhenAll(task1, task2); // takes only 5 seconds

var result1 = task1.Result;
var result2 = task2.Result;

Answer 3

Use async on all of your methods and have them return Task.

Call await Task.Delay instead of Thread.Sleep

Then, you can use await Task.WhenAll to wait for your tasks to complete.

If you do not put await in front of your method calls, execution proceeds without waiting for a result.

You can call Result to get the result once you have awaited them.

static async Task Main()
{
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();

    Task<int> task1 = DoSomeWork(1);
    Console.WriteLine($"After Task1: {stopWatch.Elapsed}");

    Task<int> task2 = DoSomeOtherWork(10);
    Console.WriteLine($"After Task2: {stopWatch.Elapsed}");

    await Task.WhenAll(task1, task2);
    stopWatch.Stop();

    int sum = task1.Result + task2.Result;
    Console.WriteLine($"Sum: {sum}");
    Console.WriteLine($"Final: {stopWatch.Elapsed}");
}

private static async Task<int> DoSomeOtherWork(int waitFor)
{
    await Task.Delay(waitFor * 1000);
    return waitFor;
}

private static async Task<int> DoSomeWork(int waitFor)
{
    await Task.Delay(waitFor * 1000);
    return waitFor;
}

output

After Task1: 00:00:00.0037888
After Task2: 00:00:00.0094963
Sum: 11
Final: 00:00:10.0126715

Answer 4

you use await keyword. async operations perform parallelly. when we need to wait until we get the result use await before it.

Example:

var task1 = AsyncOperation1(2);
var task2 = AsyncOperation1(5);


var result1 = await task1;
var result2 = await task2;

use last two line instead of Task.WhenAll(task1, task2);