When is it asynchronous and when is synchronous

Question

Having read a /lot/ of documentation on the async await pattern I thought I had a pretty good handle on the pattern. I read all about async all the way then read another article that mentions 'if it runs in under 50 milliseconds don't async it'. It seems there is conflicting information and/or opinions and I have managed to just confuse myself. I have also read that Task.Yield() will force an async decorated method to run asynchronously.

Given the following code:

    static async Task MethodA() {
        await MethodB().ConfigureAwait(false);
    }

    static async Task MethodB() {
        await Task.Yield();
        MethodC();
    }

    static void MethodC() {
        // do some synchronous stuff
    }

    static async Task Main(string[] args) {
        var task1 = Task.Run(() => MethodA().ConfigureAwait(false));
        var task2 = Task.Run(() => MethodB().ConfigureAwait(false));

        await Task.WhenAll(new List<Task>() { task1, task2 });
    }

Will MethodC run synchronously or asynchronously, I assumed asynchronously as it was called from an asynchronous method. Also, is Task.Yield necessary at all?

To be honest this is doing my head in, every article I have read delves deeper and deeper into the async await pattern with the whys and wherefores and is just adding more complexity to the question. Just looking for a simple answer.

Answer 1

Will MethodC run synchronously or asynchronously

Synchronously. It has a synchronous signature, so it will always run synchronously.

I assumed asynchronously as it was called from an asynchronous method

The context from which it is called is irrelevant to how MethodC will run.

is Task.Yield necessary at all

Well it will force MethodB to yield a Task before MethodC runs, but this will be incomplete until MethodC finishes, and because MethodC is synchronous (does not release the thread) it achieves nothing useful.

Just looking for a simple answer

async bubbles up the call stack, and because you are not consuming an async method here (MethodC is synchronous) you should not be using async at all.

Answer 2

This answer contains general info and advices, and it's not focused on the code that you posted.

1. Being confused while learning async-await is OK. Getting a perfect understanding of async-await without going through a confusion phase is practically almost impossible IMHO.
2. The await Task.Yield(), await Task.Delay(1), await Task.Run(() => { }), and .ConfigureAwait(false) are dirty hacks that people sometimes use out of frustration that an explicit way to switch imperatively to the ThreadPool context does not exist (in the standard libraries). A SwitchTo method existed in some pre-prelease .NET version, then it was removed for technical reasons, then the technical reasons were eliminated, reintroducing the method never became a high enough priority, and so it didn't happen. It may happen in the future, but don't hold your breath. It is currently available in the Microsoft.VisualStudio.Threading package, if you want it.
3. You don't need any of these hacks to write async-await code successfully. If you want to offload work to the ThreadPool, there is the Task.Run method that does the job perfectly.
4. Offloading work to the ThreadPool should be done at the "application code" level, not at the "library code" level. You can read this article to understand why exposing asynchronous wrappers for synchronous methods is not a good idea.