Can I run sync code as async to gain performance?

Question

I've read a bunch of forums, tutorials and blogs talking about the usage of Async/Await in C#. The more I read the more confusing it gets. Also, people mainly talk about calling async stuff in a sync method but not calling sync stuff in an async method.

As I am a junior developer and do not have much experience with async programming I'll post a new question here and hope for some enlightenment.

Consider this:

I have a Web API endpoint that does some calculations and model building and returns some data.

public async Task<JsonResult> GetData()
    {
        Task<Data> stuff1Task = CalculateStuff1();
        Task<Data> stuff2Task = CalculateStuff2();
        Task<Data> stuff3Task = CalculateStuff3();

        return Json(
            new
            {
                stuff1 = await stuff1Task,
                stuff2 = await stuff2Task,
                stuff3 = await stuff3Task
            }, JsonRequestBehavior.AllowGet
        );
    }

    private async Task<Data> CalculateStuff1()
    {
        return await SomeAsyncCalculation();
    }

    private async Task<Data> CalculateStuff2()
    {
        return SomeSyncCalculation();
    }

    private async Task<Data> CalculateStuff3()
    {
        Task<Data> dataTask1 = SomeAsyncCalculation();
        Task<Data> dataTask2 = AnotherAsyncCalculation();
        
        Data data1 = await dataTask1;
        Data data2 = await dataTask2;

        Data combindedData = SyncMethodToCombineData(data1, data2);

        return combindedData;
    }

Why I consider mixing async and sync code is for getting better performance. In this case lets pretend SomeAsyncCalculation(), SomeSyncCalculation() and AnotherAsyncCalculation() are pretty costly methods. My goal is to get the methods to run somewhat in parallel to gain some faster response times.

I know it is best to go "Async all the way" but lets be real, rebuilding half the project is not always a priority or a possibility. Also I might have some integrations with other systems that do not support async operations.

This warning I get for CalculateStuff2() adds to the confusion. :

this async method lacks 'await' operators and will run synchronously

In my understanding the "async" keyword is only good for wrapping the method and allowing me to use await keyword. It also allows me to just return the data and I don't need to manage Task returning results. It also handles exceptions. The Task<TResult> return type is what makes the method execute on a different thread (although it is not guaranteed it will execute on a different thread).

Concluding questions:

1. Will the async method that does not use await (CalculateStuff2()) run synchronously on it's own thread (if it runs on another thread because it is a Task) or will it run in the main thread of the API call, and always block it no matter what?

2. Is it bad practice to use async without await just to have a nicely wrapped task method out of the box?

Answer 1

You're not need for async in sync method. async generates State Machine that is a kind of redundancy in case you're not need for await.

Consider this somewhat optimized example.

public async Task<JsonResult> GetData()
{
    Task<Data> stuff1Task = CalculateStuff1();
    Task<Data> stuff3Task = CalculateStuff3();
    Data stuff2data = CalculateStuff2(); // run sync method after launching async ones

    return Json(new
           {
               stuff1 = await stuff1Task,
               stuff2 = stuff2data,
               stuff3 = await stuff3Task
           }, JsonRequestBehavior.AllowGet);
}

private Task<Data> CalculateStuff1() // optimized
{
    return SomeAsyncCalculation();
}

private Data CalculateStuff2()
{
    return SomeSyncCalculation();
}

private async Task<Data> CalculateStuff3()
{
    //use combinator to simplify the code
    Data[] data = await Task.WhenAll(SomeAsyncCalculation(), AnotherAsyncCalculation());

    Data combindedData = SyncMethodToCombineData(data[0], data[1]);

    return combindedData;
}

Also consider to differ the CPU-bound and IO-bound operations, look at this article. There's different async approach depending on what exacly you're launching.

Direct answers

1. Will the async method that does not use await (CalculateStuff2()) run synchronously on it's own thread (if it runs on another thread because it is a Task) or will it run in the main thread of the API call, and always block it no matter what?

Yes, it will run synchronously on the caller Thread. If you want to run some sync method on its own Thread, use Task.Run():

Task<Data> stuff2Task = Task.Run(() => CalculateStuff2());

and then await it.

2. Is it bad practice to use async without await just to have a nicely wrapped task method out of the box?

Yes, it's bad practice. Redundant State Machine makes overhead which in this case is worthless.