Topic 13924 min readStructured Tutorial

Cancellation Tokens in C# Asynchronous Programming

Quick Answer

Cancellation Tokens in C# provide a standardized way to cancel asynchronous operations cooperatively. They allow tasks to be cancelled safely and efficiently, improving responsiveness and resource management in asynchronous programming.

Learning Objectives

Explain the purpose of Cancellation Tokens in a practical learning context.
Identify the main ideas, terms, and decisions involved in Cancellation Tokens.
Apply Cancellation Tokens in a simple real-world scenario or practice task.

Introduction

Asynchronous programming in C# allows applications to remain responsive by running tasks in the background. However, sometimes these tasks need to be cancelled before completion.

Cancellation Tokens provide a cooperative mechanism to cancel asynchronous operations safely and efficiently.

Cancellation tokens enable graceful task cancellation without abrupt termination.

What are Cancellation Tokens?

Cancellation Tokens are objects used to signal cancellation requests to asynchronous or long-running operations.

They allow tasks to check periodically if cancellation has been requested and respond accordingly.

Implemented via the CancellationToken struct.
Controlled by a CancellationTokenSource.
Supports cooperative cancellation between caller and callee.

How to Use Cancellation Tokens

To use cancellation tokens, you create a CancellationTokenSource and pass its token to the asynchronous method.

Inside the method, you check the token's IsCancellationRequested property or call ThrowIfCancellationRequested to handle cancellation.

Create a CancellationTokenSource instance.
Pass CancellationToken to async methods.
Check token status periodically within the task.
Handle OperationCanceledException if thrown.

Example: Cancelling a Task

The following example demonstrates creating a cancellable task and cancelling it after a delay.

Best Practices for Cancellation Tokens

Proper use of cancellation tokens improves application responsiveness and resource management.

Always pass CancellationToken to async methods that support cancellation.
Check for cancellation frequently in long-running loops or operations.
Handle OperationCanceledException to clean up resources.
Avoid ignoring cancellation requests to prevent wasted work.
Use linked tokens to combine multiple cancellation sources if needed.

Common Mistakes When Using Cancellation Tokens

Misusing cancellation tokens can lead to unresponsive applications or resource leaks.

Not checking the token inside the task, causing cancellation to be ignored.
Swallowing OperationCanceledException without proper handling.
Creating CancellationTokenSource but never cancelling it.
Passing default CancellationToken which never cancels.
Not disposing CancellationTokenSource when done.

Practical Example

This example runs a task that prints iterations every 500ms. The task checks for cancellation and throws if requested. After 2 seconds, the cancellation is triggered, and the task stops gracefully.

Examples

C# Cancellation Token Example

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var cts = new CancellationTokenSource();

        var task = Task.Run(async () =>
        {
            for (int i = 0; i < 10; i++)
            {
                cts.Token.ThrowIfCancellationRequested();
                Console.WriteLine($"Iteration {i}");
                await Task.Delay(500);
            }
        }, cts.Token);

        // Cancel after 2 seconds
        await Task.Delay(2000);
        cts.Cancel();

        try
        {
            await task;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Task was cancelled.");
        }
    }
}

This example runs a task that prints iterations every 500ms. The task checks for cancellation and throws if requested. After 2 seconds, the cancellation is triggered, and the task stops gracefully.

Best Practices

Pass CancellationToken to all cancellable async methods.
Check cancellation frequently in loops or long-running operations.
Handle OperationCanceledException to clean up resources.
Dispose CancellationTokenSource after use to free resources.
Use linked tokens to combine multiple cancellation signals.

Common Mistakes

Ignoring cancellation requests inside tasks.
Not handling OperationCanceledException properly.
Forgetting to cancel the CancellationTokenSource.
Passing default CancellationToken which never cancels.
Not disposing CancellationTokenSource leading to resource leaks.

Hands-on Exercise

Implement a Cancellable Countdown

Write an asynchronous method that counts down from 10 to 0 with a delay of 1 second between counts. Use a CancellationToken to allow cancelling the countdown.

Expected output: The countdown prints numbers every second and stops immediately when cancellation is requested.

Hint: Pass a CancellationToken parameter and check for cancellation inside the loop.

Interview Questions

What is a CancellationToken in C# and why is it used?

Interview

A CancellationToken is a struct used to signal cancellation requests to asynchronous or long-running operations. It enables cooperative cancellation, allowing tasks to stop execution gracefully when cancellation is requested.

How do you trigger cancellation of a task using CancellationToken?

Interview

You trigger cancellation by calling the Cancel method on the CancellationTokenSource that created the token passed to the task. The task then observes the token and cancels accordingly.

What exception is commonly thrown when a cancellation is requested?

Interview

OperationCanceledException is thrown when a task detects a cancellation request and throws to exit the operation gracefully.