Odtnhj

Is there a benefit to using the async/await pattern when you are running things in a synchronous manner?

For instance in my app I have static methods that are called by cron (hangfire) to do various IO bound tasks. A simple contrived example is this:

static void Run(string args)

 var data = Test(args);

 //..do stuff with returned data


public static List<string> Test(string args)

 return Db.Select(args);

Is there any advantage to writing this code like so:

static void Run(string args)


 var dataTask = await TestAsync(args);
 dataTask.Wait();

 //..do stuff with returned data


public static async Task<List<string>> TestAsync(string args)

 return await Db.SelectAsync(args);

My colleague tells me that I should always use this pattern and use async methods if they are available as it adds under the hood optimization but he is unable to explain why that is and I can't really find any clear cut explanation.

If I write my code with this type of pattern in my static methods it ends up looking like:

var data = someMethod();
data.Wait();
var data2 = someOtherMethod(data);
data2.Wait();

I understand using async await pattern when firing up lots of concurrent tasks but when the code originates from a static method and has to run in order like this is there any benefit at all? Which way should I write it?

as it adds under the hood optimization but he is unable to explain why that is

It is amazing to me how many people believe that async is always the best choice yet they cannot say why. This is a big misunderstanding in the community. Unfortunately, Microsoft is kind of pushing this notion. I believe they are doing this to simplify guidance.

Async IO helps with two things: 1) save threads 2) make GUI apps easier by doing away with thread management.

Most applications are totally unconstrained by the number of threads that are running. For those apps, async IO adds zero throughput, it costs additional CPU and complicates the code. I know, because I have measured throughput and scalability. I have worked on many applications.

In particular, the IO itself does not become faster. The only thing that changes is the way the call is initiated and completed. There are no IO optimizations here whatsoever.

Use async when it is either convenient to you or you have evidence that the number of running threads will be a problem. Do not use it by default because productivity will be lower. There are additional ways to add bugs. Tooling is worse, the code is longer, debugging and profiling is harder.

Of course, there is nothing wrong with using it if it is the right tool for the job.