带/不带异步和等待的任务

Question

I have this method :

public static Task TaskMethod ()
{
    Task.Delay(30000); 
    return Task.Run(() => Console.WriteLine("From Task") ); 
}

If I call it like this:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    TaskMethod();
    Console.WriteLine("after calling the task"); 
    Console.ReadLine(); 
}

I have this output:

before calling the task
after calling the task
From Task

But if I call this:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    await TaskMethod();
    Console.WriteLine("after calling the task"); 
    Console.ReadLine(); 
}

I have this result:

before calling the task
From Task
after calling the task

Is this behavior normal? Why I'm allowed to await the task without using async?
What I'm missing?

Answer 1

I will try to explain.

Case: You don't await the returning value then it will execute the line and proceed to execute the next.

Console.WriteLine("before calling the task"); // execute 1
TaskMethod();                                 // execute 2
Console.WriteLine("after calling the task");  // execute 3

The confusing output that you get is because your machine needs less time to execute the 3rd command than it needs to execute the 2nd (creating a task, starting it, printint to console). The 2nd call runs in parallel to the 3rd. This is also due to the fact that the Task.Delay call is not waiting because you don't await it and the same principle applies there as it applies here.

To give you a little examplary proof here is a code that introduces a slight synchronous delay between the 2nd and 3rd call:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    TaskMethod();
    Thread.Sleep(50);
    Console.WriteLine("after calling the task");
    //Console.ReadLine();
}

This gives the starting of the 2nd call a little more time to be executed before the 3rd step is performed. And you get the output:

before calling the task
From Task
after calling the task

Now to the fact that the method Main runs actually synchronous on the main thread. This screenshot from LINQPad shows the message that Visual Studio would also display:

It tells you that the main method will block the main thread until it is finished. Because there is no await in it.

Whereas the TaskMethod inside the Main will run asynchronously and in parallel to the next commands which runs on the main thread! Whoever is faster gets to print it's message.

Why the Task.Delay call is useless without await ?=!

The Delay method returns a task which is started, actually quite exactly like your TaskMethod . If you don't await this delay task, it will run in parallel. Thus obliterating the entire effect of a delay. You should actually notice that your console prints all 3 lines at the same time, there is no delay between the second and third line!

Why I'm allowed to await the task without using async?

Because the necessity of async refers always to the method inside which the await call is made and not the method that is awaited! This can be seen in the fact that you cannot simply add an await to the Task.Delay call because the TaskMethod is not declared as async !

(Hopefully) last EDIT:

The await operator needs a Task whose execution it can await, and because your TaskMethod returns a Task the operator can be applied. You can make nice things with it if you take the returning task. You can then decide when to wait for the end of it's execution!:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    Task taskToBeAwaitedMuchLater = TaskMethod();
    Console.WriteLine("after calling the task");
    await taskToBeAwaitedMuchLater;
    Console.WriteLine("after awaiting the result of the task");
    //Console.ReadLine();
}

Output:

before calling the task
after calling the task
From Task
after awaiting the result of the task

Answer 2

I have this method :

public static Task TaskMethod ()
{
    Task.Delay(30000); 
    return Task.Run(() => Console.WriteLine("From Task") ); 
}

If I call it like this:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    TaskMethod();
    Console.WriteLine("after calling the task"); 
    Console.ReadLine(); 
}

I have this output:

before calling the task
after calling the task
From Task

But if I call this:

public static async Task Main()
{
    Console.WriteLine("before calling the task");
    await TaskMethod();
    Console.WriteLine("after calling the task"); 
    Console.ReadLine(); 
}

I have this result:

before calling the task
From Task
after calling the task

Is this behavior normal? Why I'm allowed to await the task without using async?
What I'm missing?