Is Sleep really blocking the execution?

Question

Nearly every introduction about async programming for C# warns against using the Sleep instruction, because it would block the whole thread.

But I found that during sleep, the Tasks from the queue are being fetched and executed. See:

    using System;
    using System.Threading.Tasks;

    namespace TestApp {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Main");
                Program.step1();

                for (int i = 0; i < 6; i++) {
                    System.Threading.Thread.Sleep(200);
                    Console.WriteLine("Sleep-Loop");
                }
            }

            private static async void step1() {
                await Task.Delay(400);
                Console.WriteLine("Step1");
                Program.step2();
            }

            private static async void step2() {
                await Task.Delay(400);
                Console.WriteLine("Step2");
            }
        }
    }

The output:

    Main
    Sleep-Loop
    Sleep-Loop
    Step1
    Sleep-Loop
    Sleep-Loop
    Step2
    Sleep-Loop
    Sleep-Loop

My questions:

1. Is Sleep really allows the queued tasks to execute, or something else happens?
2. If yes, then does this also happen in every other cases of idleness? For example during polling?
3. In the above example, if we comment out the loop, then the application exits before any tasks could get executed. Is there another way to prevent that?

Answer 1

In C# 7.3 you can have async entry points, I suggest using that.

Some notes :

1. Don't use async void, it has subtleties with the way it deals with errors, if you see yourself writing async void then think about what you are doing. If it's not for an event handler you are probably doing something wrong
2. If you want to wait for a bunch of tasks to finish, use Task.WhenAll

Modified example

static async Task Main(string[] args)
{
   Console.WriteLine("Start Task");
   var task = Program.step1();

   for (int i = 0; i < 6; i++)
   {
      await Task.Delay(100);
      Console.WriteLine("Sleep-Loop");
   }

   Console.WriteLine("waiting for the task to finish");
   await task;
   Console.WriteLine("finished");
   Console.ReadKey();
}

private static async Task step1()
{
   await Task.Delay(1000);
   Console.WriteLine("Step1");
   await Program.step2();
}

private static async Task step2()
{
   await Task.Delay(1000);
   Console.WriteLine("Step2");
}

It's important to note Tasks are not threads and async is not parallel, however they can be.

9 times out of 10 if you are using the async await pattern it is for IO bound work to use operating system I/O completion ports so you can free up threads. It's a scalability and UI responsiveness feature.

If you aren't doing any I/O work, then there is actually very little need for the async await pattern at all, and as such CPU work should probably be just wrapped in a Task.Run at the point of calling. Not wrapped in an async method.

At this point it's also good to note just using tasks are not the async and await pattern. Although they both have tasks in common, they are not the same thing.

Lastly, if you find you need to use asynchronous code in a fire and forget way, think very carefully how you will handle any errors.

Here are some guidelines.

• If you want to do I/O work, use the async await pattern.
• If you want to do CPU work use Task.Run.
• Never use async void unless it's for an event handler.
• Never wrap CPU work in an async method, let the caller use Task.Run
• If you need to wait for a task, await it, never call Result, or Wait or use Task.WhenAll