Cancellation Token Injection

Question

I'd like to be able to pass cancellation tokens via dependency injection instead of as parameters every time. Is this a thing?

We have an asp.net-core 2.1 app, where we pass calls from controllers into a maze of async libraries, handlers, and other services to fulfill the byzantine needs of the fintech regulatory domain we service.

At the top of the request, I can declare that I want a cancellation token, and I'll get one:

[HttpPost]
public async Task<IActionResult> DoSomeComplexThingAsync(object thing, CancellationToken cancellationToken) {
    await _someComplexLibrary.DoThisComplexThingAsync(thing, cancellationToken);
    return Ok();
}

Now, I want to be a good async programmer and make sure my cancellationToken gets passed to every async method down through the call chain. I want to make sure it gets passed to EF, System.IO streams, etc. We have all the usual repository patterns and message passing practices you'd expect. We try to keep our methods concise and have a single responsibility. My tech lead gets visibly aroused by the word 'Fowler'. So our class sizes and function bodies are small, but our call chains are very, very deep.

What this comes to mean is that every layer, every function, has to hand off the damn token:

private readonly ISomething _something;
private readonly IRepository<WeirdType> _repository;

public SomeMessageHandler(ISomething<SomethingElse> something, IRepository<WeirdType> repository) {
    _something = something;
    _repository = repository;
}

public async Task<SomethingResult> Handle(ComplexThing request, CancellationToken cancellationToken) {
    var result = await DoMyPart(cancellationToken);
    cancellationToken.ThrowIfCancellationRequested();
    result.SomethingResult = await _something.DoSomethingElse(result, cancellationToken);
    return result;
}

public async Task<SomethingResult> DoMyPart(ComplexSubThing request, CancellationToken cancellationToken) {
    return await _repository.SomeEntityFrameworkThingEventually(request, cancellationToken);
}

This goes on ad infinitum, as per the needs of our domain complexity. It seems like CancellationToken appears more times in our codebase than any other term. Our arg lists are often already too long (i.e. more than one) as it is, even though we declare a million object types. And now we have this extra little cancellation token buddy hanging around in every arg list, every method decl.

My question is, since Kestrel and/or the pipeline gave me the token in the first place, it'd be great if I could just have something like this:

private readonly ISomething _something;
private readonly IRepository<WeirdType> _repository;
private readonly ICancellationToken _cancellationToken;

public SomeMessageHandler(ISomething<SomethingElse> something, ICancellationToken cancellationToken)
{
    _something = something;
    _repository = repository;
    _cancellationToken = cancellationToken;
}

public async Task<SomethingResult> Handle(ComplexThing request)
{
    var result = await DoMyPart(request);
    _cancellationToken.ThrowIfCancellationRequested();
    result.SomethingResult = await _something.DoSomethingElse(result);
    return result;
}

public async Task<SomethingResult> DoMyPart(ComplexSubThing request)
{
    return await _repository.SomeEntityFrameworkThingEventually(request);
}

This would then get passed around via DI composition, and when I had something that needs the token explicitly I could do this:

private readonly IDatabaseContext _context;
private readonly ICancellationToken _cancellationToken;

public IDatabaseRepository(IDatabaseContext context, ICancellationToken cancellationToken)
{
    _context = context;
    _cancellationToken = cancellationToken;
}

public async Task<SomethingResult> DoDatabaseThing()
{
    return await _context.EntityFrameworkThing(_cancellationToken);
}

Am I nuts? Do I just pass the damn token, every damn time, and praise the async gods for the bounty that has been given? Should I just retrain as a llama farmer? They seem nice. Is even asking this some kind of heresy? Should I be repenting now? I think for async/await to work properly, the token has to be in the func decl. So, maybe llamas it is

Answer 1

This is how I inject the HttpContext cancellation token into my repositories.

WebApi/Program.cs

builder.Services.AddScoped<ICancellationTokenService, CurrentCancellationTokenService>();

WebApi/Services/CurrentCancellationTokenService.cs

public class CurrentCancellationTokenService : ICancellationTokenService
{
    public CancellationToken CancellationToken { get; }

    public CurrentCancellationTokenService(IHttpContextAccessor httpContextAccessor)
    {
        CancellationToken = httpContextAccessor.HttpContext!.RequestAborted;
    }
}

Core/Domain/Interfaces/ICancellationTokenService

public class ICancellationTokenService
{
    public CancellationToken CancellationToken { get; }
}

Persistence/Dal/Repositories/ClientRepository.cs

public class ClientRepository : IClientRepository
{
    private readonly CancellationToken _cancellationToken;

    public ClientRepository(ICancellationTokenService cancellationTokenService, ...)
    {
        _cancellationToken = cancellationTokenService.CancellationToken;
    }

    public Task<Client?> GetByIdAsync(int clientId)
    {
        return _context.Client.FirstOrDefaultAsync(x => x.Id == clientId, _cancellationToken);
    }
}

Answer 2

First of all, there are 3 injection scopes: Singleton, Scoped and Transient. Two of those rule out using a shared token.

DI services added with AddSingleton exist across all requests, so any cancellation token must be passed to the specific method (or across your entire application).

DI services added with AddTransient may be instantiated on demand and you may get issues where a new instance is created for a token that is already cancelled. They'd probably need some way for the current token to be passed to [FromServices] or some other library change.

However, for AddScoped I think there is a way, and I was helped by this answer to my similar question - you can't pass the token itself to DI, but you can pass IHttpContextAccessor.

So, in Startup.ConfigureServices or the extension method you use to register whatever IRepository use:

// For imaginary repository that looks something like
class RepositoryImplementation : IRepository {
    public RepositoryImplementation(string connection, CancellationToken cancellationToken) { }
}

// Add a scoped service that references IHttpContextAccessor on create
services.AddScoped<IRepository>(provider => 
    new RepositoryImplementation(
        "Repository connection string/options",
        provider.GetService<IHttpContextAccessor>()?.HttpContext?.RequestAborted ?? default))

That IHttpContextAccessor service will be retrieved once per HTTP request, and that ?.HttpContext?.RequestAborted will return the same CancellationToken as if you had called this.HttpContext.RequestAborted from inside a controller action or added it to the parameters on the action.

Answer 3

Just use:

services.AddHttpContextAccessor();
services.AddScoped(typeof(CancellationToken),
    serviceProvider => serviceProvider.GetRequiredService<IHttpContextAccessor>()
        .HttpContext!.RequestAborted);

Note the use of RequestAborted. This will cancel the token if the browser aborts the request.

Answer 4

Here is an easier answer than my original answer to this problem, copied from Aaron Queenan's answer below.

services.AddHttpContextAccessor();
services.AddScoped(typeof(CancellationToken), serviceProvider =>
{
   IHttpContextAccessor httpContext = serviceProvider.GetRequiredService<IHttpContextAccessor>();
   return httpContext.HttpContext?.RequestAborted ?? CancellationToken.None;
});

and then you can inject CancellationToken directly and use it

---

---

Original Answer
I think you are thinking in a great way, I do not think you need to regret or repent.
This is a great idea, I also thought about it, and I implemented my own solution

public abstract class RequestCancellationBase
{
    public abstract CancellationToken Token { get; }

    public static implicit operator CancellationToken(RequestCancellationBase requestCancellation) =>
        requestCancellation.Token;
}

public class RequestCancellation : RequestCancellationBase
{
    private readonly IHttpContextAccessor _context;

    public RequestCancellation(IHttpContextAccessor context)
    {
        _context = context;
    }

    public override CancellationToken Token => _context.HttpContext.RequestAborted;
}

and the registration should be like this

services.AddHttpContextAccessor();
services.AddScoped<RequestCancellationBase, RequestCancellation>();

now you can inject RequestCancellationBase wherever you want,
and the better thing is that you can directly pass it to every method that expects CancellationToken.
this is because of public static implicit operator CancellationToken(RequestCancellationBase requestCancellation)

here is an example of how to use it

public sealed class Service1
{
    private readonly RequestCancellationBase _cancellationToken;
    
    public Service1(RequestCancellationBase cancellationToken)
    {
         _cancellationToken = cancellationToken;
    }

    public async Task SomeMethod()
    {
        HttpClient client = new();
        // passing RequestCancellationBase object instead of passing CancellationToken
        // without any casting
        await client.GetAsync("url", _cancellationToken);
    }
}

this solution helped me, hope it is helpful for you also

Answer 5

edit I now understand the advantages of the other suggestions. I'll leave the following code in place in case it helps someone else as a mental intermediate step, but don't use it in http context.

var services = new ServiceCollection();
services.AddSingleton<CancellationTokenSource>();
services.AddSingleton(typeof(CancellationToken),
    (IServiceProvider sp) =>
    {
        var cts = sp.GetService<CancellationTokenSource>();
        ArgumentNullException.ThrowIfNull(cts);
        return cts.Token;
    });