What does calling a Task without Async/Await directly actually do?

Question

Take the simple example where the application calls the DoThis() function:

        public Task DoThis()
        {
            DoThisSub(); //Why is this being run?
            Task.Delay(100); //Yet..... Why is this ignored?
            Console.WriteLine("This is run immediately without delay");
            return Task.CompletedTask;
        }

        public Task DoThisSub()
        {
            Console.WriteLine("Yes I am being run!");
            return Task.CompletedTask;
        }

Why is DoThisSub being called but Task.Delay is not?

Answer 1

The Task.Delay method creates a new task which will be complete after some time, therefore it is not being ignored. (Reference: https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.delay?view=net-5.0)

It is being called and another thread will probably run the delay (To know exactly which thread will run a Task depends on many factors), however as the calling thread is not awaiting the Task.Delay method it will immediately continue to process the next line.

If you want for the calling thread to await the Task.Delay method there are a couple of options:

1. Make the DoThis method asyncronous and await the Task.Delay method.

   public async Task DoThis()
   {
       DoThisSub();
       await Task.Delay(100);
       Console.WriteLine("This will not be called immediately after the Task.Delay(100)");
       return Task.CompletedTask;
   }
   

2. Call the Wait() method after the Task.Delay()

   public Task DoThis()
   {
       DoThisSub();
       Task.Delay(100).Wait();
       Console.WriteLine("This will not be called immediately after the Task.Delay(100)");
       return Task.CompletedTask;
   }
   

I highly recommend that you read microsoft async/await documentation. (Reference: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/)

To address questions in comments:

why is Task.Delay run on a separate thread, where as DoThisSub() is not

The DoThisSub() method is just a regular method that returns a Task. Not all methods that return Task actually runs on new Threads. For this to happen the method needs to actually run code on a new Task as in the example below:

    public Task DoThisSub()
    {
        return Task.Run(() => 
        {
            Console.WriteLine("Yes I am being run on a new thread!");
        });
    }

Answer 2

Why is DoThisSub being called but Task.Delay is not?

They're both called. They both return task instances, which are both ignored.

There's nothing about "separate threads" going on here; all methods run on the same thread.

Answer 3

It is not ignored! it is called on a separate thread, and since you are not awaiting result control moves immediately to next statement

Answer 4

There is no direct relationships between Task and Thread. Task-await-async is a mere simplified form of Asynchronous-task + EventHandler. (Related concepts: Events, Delegates, Lambda expressions).

For example, though we are quite casually using flat code as follows these days,

async {
    Debug.WriteLine("Before");
    await Task.Delay(100);

    Debug.WriteLine("After");
    :
    Debug.WriteLine("The End");
}

Once upon a time (maybe in .NET3.x or early .NET4.x era, see C# Version History), there were no await-async syntax. There was only AsynchronousDelayTaskWorker class or something which (1) takes event handler, (2) runs time-consuming task asynchronously and then (3) fires the event in the end. To use such apparatus, programmers had to write complex structured code as follows.

{
   Debug.WriteLine("Before");
   var worker = new AsynchronousDelayTaskWorker();
   worker.SetCompletedEventHandler(new CompletedEventHander(()=>
   {
       // Whether this handler is dispatched on the original thread or not
       // depends on worker's implementation. 

       Debug.WriteLine("After");
       :
       Debug.WriteLine("The End");
   }));
   worker.RunAsync();
}

But after task-async-await were introduced in .NET4.5, it became possible to write such a code in a flat and clean manner as follows.

async {

    Debug.WriteLine("Before");
    await Task.Delay(100);

    // Following codes are actually placed in event handler.
    Debug.WriteLine("After");
    :
    Debug.WriteLine("The End");
}

—— And C# programmers lived happily ever after.

Using task without await is nearly equivalent to running the legacy asynchronous task without registering event handler. The task runs asynchronously somewhere (in many cases in background thread). It's not possible to run another code after the task completes because it's unknown when the task finishes/finished, without event handler.

Since the task is mere object which doesn't interfere with subsequent codes, all the lines run straightforwardly.

{
    Debug.WriteLine("Before");

    // The following worker runs somewhere 
    // as the raw Task.Delay(100) does.
    var worker = new AsynchronousDelayTaskWorker();
    worker.RunAsync(); 

    // Following codes run immediately.
    Debug.WriteLine("After"); 
    :
    Debug.WriteLine("The End");
}