Efficiently managing long-running operations is essential in .NET applications. Whether dealing with API requests, database interactions, or background services, developers often encounter scenarios where gracefully canceling operations can enhance performance and optimize resource usage. The CancellationToken plays a key role in achieving this by providing a structured, cooperative approach to task cancellation, keeping applications responsive and efficient. This article explores the benefits of the CancellationToken, real-world use cases, as well as a practical implementation.

Benefits of CancellationToken in .NET

Using CancellationToken in .NET provides several advantages:

• Efficient Resource Management — Prevents unnecessary processing by stopping tasks that are no longer needed. By using CancellationToken, you can stop a running process before it completes if it’s no longer needed, freeing up system resources for more important tasks.
• Graceful Cancellation — Allows operations to clean up resources, close connections, and exit safely. This means releasing memory, closing database connections, stopping background processes, and handling any necessary finalization logic before the task is terminated.
• Improved Responsiveness —An application remains fast and responsive by canceling background operations that are no longer needed. This prevents unnecessary processing from slowing down the UI or blocking user interactions.
• Better User Experience — By implementing cancellation, users don’t have to wait indefinitely for a task that is no longer relevant. Instead of sitting through a long wait time, they can continue using the application without interruptions.
• Seamless Integration with .NET APIs — Works with Task.Run, HttpClient, Entity Framework, and background services.

Task Run Example

This C# console application demonstrates how to cancel a long-running operation using a CancellationToken. It creates a CancellationTokenSource and starts a task that simulates work in a loop. After a 2-second delay, the operation is canceled by calling Cancel(). The task checks for cancellation requests and throws an OperationCanceledException if canceled, which is caught to display a message indicating that the operation was canceled.

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

class Program
{
    static async Task Main(string[] args)
    {
        var cancellationTokenSource = new CancellationTokenSource();
        var token = cancellationTokenSource.Token;

        Task task = Task.Run(() => LongRunningOperation(token), token);

        // Simulate user cancelling the operation
        await Task.Delay(2000); // Wait for 2 seconds
        cancellationTokenSource.Cancel();

        try
        {
            await task; // Await the task to catch any exceptions
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Operation was canceled.");
        }
    }

    static void LongRunningOperation(CancellationToken token)
    {
        for (int i = 0; i < 10; i++)
        {
            token.ThrowIfCancellationRequested();
            Thread.Sleep(1000); // Simulate work
            Console.WriteLine("Working...");
        }
    }
}

HttpClient Example

This C# console application fetches data asynchronously from an API using HttpClient, with cancellation support via a CancellationToken. It simulates cancellation after 1 second. If the request is canceled, it catches an OperationCanceledException and prints “Request was canceled.”

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var cancellationTokenSource = new CancellationTokenSource();
        var token = cancellationTokenSource.Token;

        try
        {
            var result = await FetchDataAsync(token);
            Console.WriteLine(result);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Request was canceled.");
        }

        // Simulate user canceling the request
        cancellationTokenSource.CancelAfter(1000); // Cancel after 1 second
    }

    static async Task<string> FetchDataAsync(CancellationToken token)
    {
        using (var httpClient = new HttpClient())
        {
            var response = await httpClient.GetAsync("https://jsonplaceholder.typicode.com/todos/1", token);
            return await response.Content.ReadAsStringAsync();
        }
    }
}

Entity Framework Example

The application creates a CancellationTokenSource to manage cancellation requests. It then uses a MyDbContext to asynchronously fetch the first entity from the database. If the operation is canceled (simulated after 1 second), it catches an OperationCanceledException and prints “Database operation was canceled.”

using System;
using System.Data.Entity; // or using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var cancellationTokenSource = new CancellationTokenSource();
        var token = cancellationTokenSource.Token;

        using (var context = new MyDbContext())
        {
            try
            {
                var entity = await context.Entities.FirstOrDefaultAsync(token);
                Console.WriteLine(entity.Name);
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Database operation was canceled.");
            }

            // Simulate user canceling the operation
            cancellationTokenSource.CancelAfter(1000); // Cancel after 1 second
        }
    }
}

Background Services Example

The MyBackgroundService class defines an asynchronous task that simulates work by delaying for 1 second in a loop, checking for cancellation via the provided CancellationToken. The Program class sets up a host, registers the background service, and runs the host asynchronously. The background task will continue running until a cancellation request is received.

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;

public class MyBackgroundService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Simulate work
            await Task.Delay(1000, stoppingToken); // Pass the cancellation token to the delay
            Console.WriteLine("Running background task...");
        }
    }
}

class Program
{
    public static async Task Main(string[] args)
    {
        using var host = Host.CreateDefaultBuilder(args)
            .ConfigureServices(services =>
            {
                services.AddHostedService<MyBackgroundService>();
            })
            .Build();

        await host.RunAsync(); // Run the host, which includes the background service
    }
}

Practical Example — Implementing CancellationToken Processing Orders in an E-Commerce System

Imagine we are developing an e-commerce system where users can place orders. The system processes each order asynchronously by checking inventory, reserving stock, and confirming payment. However, users can cancel their order before completion. Without a cancellation mechanism, the system would continue processing the order even if the user has already abandoned it.

By implementing CancellationToken, we can efficiently stop the order processing when the user requests a cancellation, freeing up resources for other critical operations.

1️⃣ Creating the Order Processing Service

This code defines an interface named IOrderProcessingService that specifies a contract for processing orders asynchronously.

public interface IOrderProcessingService
{
    Task ProcessOrderAsync(Guid orderId, CancellationToken cancellationToken);
}

2️⃣ Implementing Order Processing with Cancellation Support

The OrderProcessingService class implements the IOrderProcessingService interface, providing an asynchronous method ProcessOrderAsync. This method processes an order by simulating three steps: checking inventory, reserving stock, and processing payment, each with a 2-second delay. It logs the start of the order processing and a completion message, while supporting cancellation through the provided CancellationToken.

public class OrderProcessingService : IOrderProcessingService
{
    public async Task ProcessOrderAsync(Guid orderId, CancellationToken cancellationToken)
    {
        Console.WriteLine($"Starting order processing for Order ID: {orderId}");

        // Step 1: Check inventory
        await Task.Delay(2000, cancellationToken); // Simulating async call
        Console.WriteLine("Inventory checked.");

        // Step 2: Reserve stock
        await Task.Delay(2000, cancellationToken);
        Console.WriteLine("Stock reserved.");

        // Step 3: Process payment
        await Task.Delay(2000, cancellationToken);
        Console.WriteLine("Payment processed.");

        Console.WriteLine($"Order {orderId} completed successfully.");
    }
}

3️⃣ Simulating a User Cancelling the Order

Next, we use the OrderProcessingService to process an order asynchronously with cancellation support. It creates a CancellationTokenSource, starts processing an order with a generated orderId, and simulates user cancellation after 3 seconds. If the order is canceled, it catches the OperationCanceledException and logs a cancellation message.

class Program
{
    static async Task Main(string[] args)
    {
        var cts = new CancellationTokenSource();
        var orderService = new OrderProcessingService();
        var orderId = Guid.NewGuid();

        var orderTask = orderService.ProcessOrderAsync(orderId, cts.Token);

        // Simulating user cancellation after 3 seconds
        await Task.Delay(3000);
        Console.WriteLine("User requested order cancellation.");
        cts.Cancel();

        try
        {
            await orderTask;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine($"Order {orderId} was cancelled before completion.");
        }
    }
}

4️⃣ Expected Output

Starting order processing for Order ID: a3c4...
Inventory checked.
User requested order cancellation.
Order a3c4... was cancelled before completion.

In this example, the cancellation request stops the process before the payment step, preventing unnecessary operations.

The CancellationToken is an essential tool for handling task cancellations in .NET applications. It ensures that resources are used efficiently, prevents unnecessary operations, and improves overall application responsiveness. By integrating it into real-world scenarios, such as order processing, developers can build more robust and user-friendly systems. Whether you’re working on APIs, background jobs, or UI-based applications, leveraging CancellationToken can significantly enhance the efficiency and reliability of your .NET applications.