Using HttpContext in a background task after response has been completed

A user can trigger a long-running job by sending a request to an ASP.NET Core controller. Currently, the controller executes the job and then sends a 200 OK response. The problem is that the client has to wait rather long for the response.

This is why I am currently trying to process the job in a background task. I am using an IBackgroundTaskQueue where all jobs are stored and an IHostedService that processes the jobs whenever a new one is enqueued. It is similar to the code in the Microsoft documentation.

But the job does need access to the database and therefore the user has to authenticate using Active Directory. Hence, I need access to the HttpContext.User property in the background task. Unfortunately, the HttpContext is disposed when the response is sent and before the processing of the job begins.

Demonstration

public class Job
{
    public Job(string message)
    {
        Message = message;
    }

    public string Message { get; }
}

The controller enqueues a new job in the task queue.

[HttpGet]
public IActionResult EnqueueJob()
{
    var job = new Job("Hello World");
    this.taskQueue.QueueBackgroundWorkItem(job);
    return Accepted();
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private ConcurrentQueue<Job> jobs = new ConcurrentQueue<Job>();
    private SemaphoreSlim signal = new SemaphoreSlim(0);

    public void QueueBackgroundWorkItem(Job job)
    {
        jobs.Enqueue(job);
        signal.Release();
    }

    public async Task<Job> DequeueAsync(CancellationToken cancellationToken)
    {
        await signal.WaitAsync(cancellationToken);
        jobs.TryDequeue(out var job);
        return job;
    }
}

The IHostedService creates a new JobRunner for each job it dequeues. I'm using a IServiceScopeFactory here to have dependency injection available. JobRunner also has a lot more dependencies in the real code.

public class JobRunnerService : BackgroundService
{
    private readonly IServiceScopeFactory serviceScopeFactory;
    private readonly IBackgroundTaskQueue taskQueue;

    public JobRunnerService(IServiceScopeFactory serviceScopeFactory, IBackgroundTaskQueue taskQueue)
    {
        this.serviceScopeFactory = serviceScopeFactory;
        this.taskQueue = taskQueue;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (stoppingToken.IsCancellationRequested == false)
        {
            var job = await taskQueue.DequeueAsync(stoppingToken);

            using (var scope = serviceScopeFactory.CreateScope())
            {
                var serviceProvider = scope.ServiceProvider;
                var runner = serviceProvider.GetRequiredService<JobRunner>();
                runner.Run(job);
            }

        }
    }
}

public class JobRunner
{
    private readonly ILogger<JobRunner> logger;
    private readonly IIdentityProvider identityProvider;

    public JobRunner(ILogger<JobRunner> logger, IIdentityProvider identityProvider)
    {
        this.logger = logger;
        this.identityProvider= identityProvider;
    }

    public void Run(Job job)
    {
        var principal = identityProvider.GetUserName();
        logger.LogInformation($"{principal} started a new job. Message: {job.Message}");
    }
}

public class IdentityProvider : IIdentityProvider
{
    private readonly IHttpContextAccessor httpContextAccessor;

    public IdentityProvider(IHttpContextAccessor httpContextAccessor)
    {
        this.httpContextAccessor = httpContextAccessor;
    }

    public string GetUserName()
        => httpContextAccessor.HttpContext.User.Identity.Name; // throws NullReferenceException
}

Now, when sending a request, a NullReferenceException is thrown in JobRunner.Run() because httpContextAccessor.HttpContext is null.

What I've tried

I haven't had a good idea yet how to approach this problem. I know that it would be possible to copy the necessary information from the HttpContext, but don't know how to make them available to dependency injection services.

I thought that maybe I could create a new IServiceProvider that uses the services of an old one, but replaces the implementation for IHttpContextAccesor, but it does not seem to be possible.

How can I use the HttpContext in the background task although the response has been completed?