CancellationToken Not Working in ASP.NET Core Web API HostedService? Here’s the Fix!

Are you struggling to get CancellationToken working in your ASP.NET Core Web API HostedService? You’re not alone! Many developers have faced this issue, and it’s more common than you think. In this article, we’ll dive into the world of CancellationToken, explore the common pitfalls, and provide a step-by-step guide to get it working seamlessly in your ASP.NET Core Web API HostedService.

What is CancellationToken?

CancellationToken is a mechanism in .NET that allows you to cancel asynchronous operations. It’s a simple yet powerful concept that helps you handle timeouts, cancellations, and cooperative task terminations. In the context of ASP.NET Core Web API, CancellationToken is essential for handling long-running tasks, such as database queries or third-party API calls, that might need to be cancelled prematurely.

The Problem: CancellationToken Not Working in HostedService

So, why does CancellationToken not work in ASP.NET Core Web API HostedService? The issue lies in the way HostedService is designed. By default, HostedService inherits from the IHostedService interface, which doesn’t provide a CancellationToken. This means that when you inject a CancellationToken into your HostedService, it will always be null.

To demonstrate this, let’s create a simple HostedService that tries to use CancellationToken:

public class MyHostedService : IHostedService
{
    private readonly CancellationToken _cancellationToken;

    public MyHostedService(CancellationToken cancellationToken)
    {
        _cancellationToken = cancellationToken;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("StartAsync called");
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("StopAsync called");
        return Task.CompletedTask;
    }
}

In this example, the CancellationToken is always null, even when you inject it through the constructor. This is because the IHostedService interface doesn’t provide a CancellationToken.

Solution 1: Using IHostedService with CancellationToken

The first solution is to create a custom implementation of IHostedService that accepts a CancellationToken. This approach requires some manual work, but it’s a viable solution:

public interface IHostedServiceWithCancellationToken : IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync(CancellationToken cancellationToken);
}

public class MyHostedService : IHostedServiceWithCancellationToken
{
    private readonly CancellationToken _cancellationToken;

    public MyHostedService(CancellationToken cancellationToken)
    {
        _cancellationToken = cancellationToken;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("StartAsync called with CancellationToken");
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("StopAsync called with CancellationToken");
        return Task.CompletedTask;
    }
}

In this example, we’ve created a custom interface IHostedServiceWithCancellationToken that extends IHostedService. We’ve also implemented this interface in our MyHostedService class, which now accepts a CancellationToken in its constructor. This solution works, but it has some limitations.

Limits of IHostedServiceWithCancellationToken

The main limitation of this approach is that it requires manual registration of the HostedService in the DI container. You’ll need to register your custom interface and implementation in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton();
}

This adds an extra layer of complexity and makes the code harder to maintain.

Solution 2: Using BackgroundService with CancellationToken

A better solution is to use the BackgroundService class, which is a built-in implementation of IHostedService that provides a CancellationToken. This approach is more straightforward and easier to maintain:

public class MyBackgroundService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        Console.WriteLine("ExecuteAsync called with CancellationToken");
        await Task.CompletedTask;
    }
}

In this example, we’ve created a BackgroundService class that inherits from the BackgroundService class. The ExecuteAsync method provides a CancellationToken, which we can use to cancel the operation.

Note that you don’t need to register this class in the DI container. ASP.NET Core will automatically discover and register it as a BackgroundService.

Best Practices for Using CancellationToken

Now that we’ve covered the solutions, let’s discuss some best practices for using CancellationToken in your ASP.NET Core Web API HostedService:

• Always pass CancellationToken to async methods: When calling async methods, always pass the CancellationToken to ensure that the operation can be cancelled.
• Check CancellationToken.IsCancellationRequested: Before starting a long-running task, check if the CancellationToken.IsCancellationRequested property is true. If it is, cancel the operation promptly.
• Use CancellationToken.ThrowIfCancellationRequested(): Instead of checking CancellationToken.IsCancellationRequested, use CancellationToken.ThrowIfCancellationRequested() to throw an OperationCanceledException if the token is cancelled.
• Avoid blocking calls with CancellationToken: When using CancellationToken, avoid making blocking calls that might block the thread. Instead, use async methods and await the result.

Conclusion

In this article, we’ve explored the common issue of CancellationToken not working in ASP.NET Core Web API HostedService. We’ve discussed two solutions: using a custom IHostedServiceWithCancellationToken interface and using the BackgroundService class. We’ve also covered some best practices for using CancellationToken in your HostedService.

By following these guidelines, you can ensure that your ASP.NET Core Web API HostedService is cancellation-friendly and can handle timeouts, cancellations, and cooperative task terminations with ease.

Comparison of Solutions

Solution	Advantages	Disadvantages
IHostedServiceWithCancellationToken	Customizable, flexible	Manual registration required, adds complexity
BackgroundService	Built-in support, easy to use	Limited customization options

Choose the solution that best fits your needs, and happy coding!

FAQs

1. Q: Why does CancellationToken not work in HostedService?
   A: HostedService doesn’t provide a CancellationToken by default. We need to use a custom implementation or the BackgroundService class to get it working.
2. Q: What’s the difference between IHostedService and BackgroundService?
   A: IHostedService is an interface that provides a basic implementation for hosted services. BackgroundService is a built-in implementation of IHostedService that provides a CancellationToken.
3. Q: How do I cancel a long-running task in ASP.NET Core?
   A: Use CancellationToken to cancel the task. You can also use CancellationTokenSource to cancel the task from the outside.

Frequently Asked Question

Stuck with CancellationToken not working in ASP.NET Core Web API HostedService? We’ve got you covered! Here are some frequently asked questions to get you back on track.