Introduction

Cancellation in async code is cooperative, not magical. The caller signals that work should stop, and the async method must observe that signal, stop at safe points, and clean up correctly. In .NET, that pattern is built around CancellationToken, CancellationTokenSource, and OperationCanceledException.

Accept a CancellationToken

If a method can take noticeable time, let the caller pass a token.

1using System;
2using System.Threading;
3using System.Threading.Tasks;
4
5public static async Task<int> CountAsync(int limit, CancellationToken cancellationToken)
6{
7    int total = 0;
8
9    for (int i = 0; i < limit; i++)
10    {
11        cancellationToken.ThrowIfCancellationRequested();
12        await Task.Delay(100, cancellationToken);
13        total += i;
14    }
15
16    return total;
17}

Two important details are happening here:

• the loop checks the token explicitly
• awaited operations also receive the token

That makes cancellation responsive instead of delayed.

Trigger Cancellation from the Caller

The caller usually owns the CancellationTokenSource.

1using System;
2using System.Threading;
3using System.Threading.Tasks;
4
5public static async Task DemoAsync()
6{
7    using var cts = new CancellationTokenSource();
8    cts.CancelAfter(TimeSpan.FromSeconds(1));
9
10    try
11    {
12        int result = await CountAsync(100, cts.Token);
13        Console.WriteLine(result);
14    }
15    catch (OperationCanceledException)
16    {
17        Console.WriteLine("Operation canceled");
18    }
19}

CancelAfter is useful for timeouts, while direct Cancel() is useful for UI buttons or shutdown events.

Propagate the Token Downstream

One of the most common mistakes is accepting a token but not passing it to nested async operations. If your method calls HTTP, database, or file APIs that support cancellation, forward the same token.

1using System.Net.Http;
2
3public static async Task<string> FetchAsync(HttpClient client, string url, CancellationToken token)
4{
5    using var response = await client.GetAsync(url, token);
6    return await response.Content.ReadAsStringAsync(token);
7}

If the top-level method is cancelable but inner I/O ignores the token, the cancellation experience will feel broken.

Clean Up Correctly

Cancellation is not an error in the same sense as a bug or infrastructure failure, but cleanup still matters. Use finally blocks for owned resources.

1public static async Task ProcessAsync(CancellationToken token)
2{
3    Console.WriteLine("Starting");
4    try
5    {
6        await Task.Delay(5000, token);
7    }
8    finally
9    {
10        Console.WriteLine("Cleanup runs even on cancellation");
11    }
12}

Do not swallow OperationCanceledException silently unless that is the API contract. In many cases, the caller needs to know work did not finish.

Cancellation vs Failure

Keep cancellation distinct from ordinary failure handling:

• cancellation means the caller requested stop
• failure means the operation tried to finish but could not

If you convert cancellation into a generic error, callers lose important control-flow information.

UI and Background-Service Patterns

Typical patterns include:

• cancel button in desktop or mobile UI
• web request aborted by client disconnect
• hosted service shutting down gracefully
• batch job timeout

In all of these, cooperative cancellation is better than forcing a thread or task to stop abruptly.

Linked Tokens for Combined Policies

Sometimes an operation should stop if either the caller cancels or an internal timeout expires. Linked token sources handle that cleanly.

1using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
2using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
3    callerToken,
4    timeoutCts.Token
5);
6
7await CountAsync(100, linkedCts.Token);

This keeps timeout policy and user-requested cancellation in one cooperative flow.

Common Pitfalls

• Defining a cancelable async method but never accepting a CancellationToken.
• Checking the token once at the start and never again during long work.
• Forgetting to pass the token into awaited operations that support cancellation.
• Swallowing OperationCanceledException and pretending the work completed normally.
• Treating cancellation as a crash instead of expected control flow.

Summary

• Async cancellation in .NET is cooperative and token-driven.
• Methods should accept a CancellationToken and observe it during work.
• Callers use CancellationTokenSource to request stop or apply timeouts.
• Propagate the same token into nested async operations.
• Clean up resources and let cancellation remain distinguishable from real failure.