Why does Main not wait for all threads to evaluate in asynchronous program?

Question

@Dan Dinu's answer from a previous question regarding asynchronous programming in C# provides a useful minimal example, which I have adapted as follows:

// From https://stackoverflow.com/questions/14455293/how-and-when-to-use-async-and-await

using System;
using System.Threading.Tasks;

namespace minimal_async_await_SE
{
    internal class Program
    {
        public static async Task MyMethodAsync()
        {
            Task<int> longRunningTask = LongRunningOperationAsync();
            // independent work which doesn't need the result of LongRunningOperationAsync
            // can be done here
            Console.WriteLine("Independent work");
            //Call await on the task
            int result = await longRunningTask;
            Console.WriteLine(result);
        }

        public static async Task<int> LongRunningOperationAsync()
        {
            await Task.Delay(1000);
            return 1;

        }

        static void Main(string[] args)
        {
            MyMethodAsync();
            Console.WriteLine("Returned to Main");
            //Console.ReadKey();
        }
    }
}

If I uncomment line 32, I get the following expected result:

Independent work
Returned to Main
1

Basically:

Main calls MyMethodAsync
MyMethodAsync calls LongRunningOperationAsync
LongRunningOperationAsync then calls Task.Delay, but awaits it which suspends further evaluation of the enclosing method LongRunningOperationAsync, returning control to the caller, namely MyMethodAsync.
MyMethodAsync prints out "Independent work".
MyMethodAsync attempts to assign the result of LongRunningOperation to resultbutawaits it, suspends evaluation of the enclosing MyMethodAsync, and returns control of the program back to Main`
Main prints out "Returned to Main"
Task.Delay(1000) in LongRunningOperationAsync() completes
A new thread is spawned, In the caller of LongRunningOperationAsync (MyMethodAsync) the integer 1 is assigned to result.
Evaluation of MyMethodAsync completes, and MyMethodAsync prints out the value of result
Control is given back to Main, which suspends evaluation until the user enters a key via Console.ReadKey

Firstly, is my understanding of how this program evaluates correct? Secondly, why is it that when I comment Console.ReadKey, I get the following unexpected result?

Independent work
Returned to Main

Does the Main method not wait for all threads to get evaluated before exiting out of the program? Why or why not?

The simple answer is, because it doesn't! It isn't designed to. You can fix this by having `static async Task Main(string[] args)` and then awaiting `await MyMethodAsync()` — Shane, May 21 '22 at 10:12
Both of your answers make sense, but that begs the more philosophical question: what calls `Main` itself? — user32882, May 21 '22 at 10:17
The compiler bootstraps the application to call main as the entry point in various situations, its a language feature and well documented. However I think your main issue is with the async and await semantics and pattern, it's probably best to start your learning journey there — TheGeneral, May 21 '22 at 10:31
Why would it? If you have an async Task and you don't tell the runtime to wait for it, it doesn't ... And once the `Main` method comes to an end, the whole programm ends. If you want to wait for your task, you have tell the runtime accordingly. Ie make the `Main` method `async` as well and use `await MyMethodAsync()` ... — derpirscher, May 21 '22 at 10:45
Link to the docs: [Main() and command-line arguments](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/program-structure/main-command-line) — Theodor Zoulias, May 21 '22 at 11:46

Shane · Accepted Answer · 2022-05-21T10:37:43.760

The answer to your question "Why or why not?" is complex, but could be answered with a better understanding of a Task.

A Task is not a thread. Many tasks can run on a single thread, and a single task can be run on multiple threads.

A task is more like an event, that will trigger a scheduler to run some code on whatever thread it has available at the time (ignoring some complex issues of continuation)

So your question could be re-phrased to "why does my program not listen to all events and block execution until all have fired?". The answer to that question probably kept 1 or 2 designers of the TPL (Tasks) awake at night, and ultimately they decided that the effects of this decision had the potential to do some serious harm to other types of applications

The designers of TPL did give us a way around this (a few editions of C# later) which is async Main methods. In your case it would look like this:

    static async Task Main(string[] args)
    {
        await MyMethodAsync();
        Console.WriteLine("Returned to Main");
    }

Why does Main not wait for all threads to evaluate in asynchronous program?

1 Answers1