How and When to Use async and await in C#

By the end of this page, you will understand that async and await in C# do not automatically create background threads. You will learn what async really means, what await pauses, why Thread.Sleep() blocks execution, and how to write truly asynchronous code using APIs like Task.Delay() instead of blocking calls.

What async and await really do

In C#, async and await are language features for working with asynchronous operations. They help you write code that looks sequential while allowing the program to avoid blocking the current thread when possible.

A very common beginner misunderstanding is this:

• Myth: async automatically runs code on another thread.
• Reality: async by itself does not start a new thread.

What async does

Marking a method with async allows you to use await inside it. That is its main purpose.

For example:

async Task<int> GetValueAsync()
{
    int value = await SomeOperationAsync();
    return value;
}

Without async, you cannot use inside the method body.

Think of async/await like ordering food at a restaurant.

• Synchronous code: You stand at the counter and refuse to move until your food is ready. Nobody else can use your spot.
• Asynchronous code: You place your order, get a buzzer, and step aside. When the food is ready, the buzzer tells you to come back.

Now apply that to your code:

• Task is the buzzer ticket.
• await is stepping aside until the food is ready.
• Thread.Sleep() is standing still at the counter for 5 seconds and blocking everyone behind you.

So await is not “make a new worker.” It is more like “pause here and come back later when the work finishes.”

If the work itself is just blocking the current thread, like Thread.Sleep(), nothing is really gained.

Basic syntax

async Task MyMethodAsync()
{
    await SomeTaskReturningMethodAsync();
}

Methods that commonly use async

async Task DoWorkAsync()
{
    await Task.Delay(1000);
}

async Task<int> GetNumberAsync()
{
    await Task.Delay(1000);
    return 42;
}

async void button1_Click(object sender, EventArgs e)
{
    await DoWorkAsync();
}

Return type guide

• async Task → async method with no result
• async Task<T> → async method that returns a value
• async void → usually only for event handlers

Your original example fixed

Example to trace

private async void button1_Click(object sender, EventArgs e)
{
    Console.WriteLine("Click start");

    Task<int> task = DoSomethingAsync();

    Console.WriteLine("After calling DoSomethingAsync");

    int x = await task;

    Console.WriteLine($"Result: {x}");
}

async Task<int> DoSomethingAsync()
{
    Console.WriteLine("DoSomethingAsync started");
    await Task.Delay(2000);
    Console.WriteLine("DoSomethingAsync finished");
    return 1;
}

What happens step by step

1. The button is clicked.
2. button1_Click starts running on the UI thread.
3. Console.WriteLine("Click start") runs.
4. DoSomethingAsync() is called.
5. Inside DoSomethingAsync, Console.WriteLine("DoSomethingAsync started") runs immediately.
6. The method reaches .

Where async/await is useful

Web requests

var response = await httpClient.GetAsync(url);

The app can do other work while waiting for the server.

Reading files

string text = await File.ReadAllTextAsync(path);

Useful when loading large files without freezing a UI.

Database queries

var user = await dbContext.Users.FindAsync(id);

Common in ASP.NET and desktop apps.

UI event handlers

private async void loadButton_Click(object sender, EventArgs e)
{
    statusLabel.Text = "Loading...";
    var data = await LoadDataAsync();
    statusLabel.Text = "Done";
}

The UI stays responsive while data loads.

How this concept is used in real projects

Async all the way

If one method awaits another, the calling method often becomes async too.

public async Task SaveAsync()
{
    await repository.SaveAsync();
}

This avoids blocking with .Result or .Wait().

Event handlers use async void

In UI frameworks, event handlers are one of the few correct places for async void.

private async void submitButton_Click(object sender, EventArgs e)
{
    await SubmitFormAsync();
}

Guard clauses before awaiting

public async Task<string> LoadUserAsync(int id)
{
    if (id <= )
          ArgumentException();

      api.GetUserAsync(id);
}

1. Thinking async creates a new thread

Broken assumption:

async Task DoWorkAsync()
{
    Thread.Sleep(5000);
}

Why it is wrong:

• async does not move this to another thread
• Thread.Sleep still blocks the current thread

Better:

async Task DoWorkAsync()
{
    await Task.Delay(5000);
}

2. Marking a method async without await

async Task<int> GetNumberAsync()
{
    return 1;
}

This compiles with a warning and is usually unnecessary.

Better:

Task<> ()
{
     Task.FromResult();
}

Related concepts compared

Quick rules

• async lets you use await
• await pauses the method, not the whole program
• async does not automatically create a new thread
• An async method runs synchronously until its first incomplete await
• Thread.Sleep() blocks the current thread
• Task.Delay() is the async, non-blocking alternative
• Use async Task or async Task<T> for most async methods
• Use async void mainly for event handlers
• Avoid .Wait() and .Result when possible

Common patterns

async Task DoWorkAsync()
{
    await Task.Delay(1000);
}

async Task<int> ()
{
     Task.Delay();
     ;
}

Why does code before await still run immediately?

Because an async method starts executing normally. It only pauses when it reaches an incomplete awaited task.

Does await create a new thread?

No. await waits for a task to finish without blocking the current thread. It does not itself create threads.

Why did int a = 1; not run immediately in the example?

Because DoSomethingAsync() used Thread.Sleep(5000), which blocked the current thread before returning control.

Why must button1_Click be marked async?

Because it uses await access;. A method must be marked async if it contains await.

Is async void bad?

Usually yes for normal methods, but it is appropriate for event handlers in UI code.

What should I use instead of Thread.Sleep() in async code?

Use await Task.Delay(...) for delays, or use truly asynchronous APIs for I/O operations.

• Task — the object that represents ongoing asynchronous work.
• Task<T> — a task that eventually produces a result.
• Task.Delay — the non-blocking way to wait for time to pass.
• Thread.Sleep — a blocking delay, useful to contrast with async waiting.
• Task.Run — used for running CPU-bound work on a thread pool thread.
• async Task vs async void — important for choosing correct async method return types.
• UI thread — helpful for understanding why blocking calls freeze desktop apps.
• I/O-bound vs CPU-bound work — essential for knowing when async helps.
• Exception handling in async methods — exceptions behave differently around awaited tasks.