Leveraging user context in an IHostedService via DI

Question

I have a series of class libraries that are used in asp.net-core middleware, and in an IHostedService.

To fetch the user context, I can inject IHttpContextAccessor to grab the HttpContext user:

public class MyLibrary 
{
  public MyLibrary(IHttpContextAccessor accessor)
  {
    // set the accessor - no problem
  }
  
  public async Task DoWorkAsync(SomeObject payload) 
  { 
    // get the user from the accessor
    // do some work
  }
}

To be a little more abstract, I have an IUserAccessor with an HttpUserAccessor implementation:

public class HttpUserAccessor: IUserAccessor
{
  IHttpContextAccessor _httpaccessor;
  public HttpUserAccessor(IHttpContextAccessor accessor) 
  {
    _httpaccessor = accessor;
  }

  public string GetUser()
  {
    // return user from _httpaccessor
  }
}

and then MyLibrary does not need an IHttpContextAccessor dependency:

public class MyLibrary 
{
  public MyLibrary(IUserAccessor accessor)
  {
    // set the accessor - no problem
  }
  
  public async Task DoWorkAsync(SomeObject payload) 
  { 
    // get the user from the accessor
    // do some work
  }
}

My IHostedService is popping message from a queue, where the message includes:

• a user context, and
• a serialized SomeObject to pass to MyLibrary.DoWorkAsync

So, something like:

public class MyHostedService : IHostedService
{
  IServiceScopeProvider _serviceScopeFactory;

  public MyHostedService(IServiceScopeFactory serviceScopeFactory) 
  {
    _serviceScopeFactory = servicesScopeFactory;
  }

  public Task StartAsync(CancellationToken cancellationToken)
  { ... }

  public Task StopAsync(CancellationToken cancellationToken)
  { ... }

  public async Task ExecuteAsync(CancellationToken stoppingToken)
  {
    foreach (var message in queue) 
    {
      using (var scope = _serviceScopeFactory.CreateScope()) 
      {
        // todo: tell IUserAccessor what message.User is!
        var payload = // create a SomeObject from the queue message
        var mylibrary = _services.GetRequiredService<MyLibrary>();
        await myLibrary.DoWorkAsync(payload);
      }
    }
  }
}

So, my question is, how does MyHostedService store message.User in such a way that a custom IUserAccessor can access it in a thread-safe manner via DI?

Answer 1

how does MyHostedService store message.User in such a way that a custom IUserAccessor can access it in a thread-safe manner via DI?

The thing you're looking for is AsyncLocal<T> - it's like a thread-local variable but scoped to a (possibly asynchronous) code block instead of a thread.

I tend to prefer a "provider" + "accessor" pairing for this: one type that provides the value, and a separate type that reads the value. This is logically the same thing as a React Context in the JS world, though the implementation is quite different.

One tricky thing about AsyncLocal<T> is that you need to overwrite its value on any change. In this case, that's not really a problem (no message processing will want to update the "user"), but in the general case it's important to keep in mind. I prefer storing immutable types in the AsyncLocal<T> to ensure they aren't mutated directly instead of overwriting the value. In this case, your "user" is a string, which is already immutable, so that's perfect.

First, you'll need to define the actual AsyncLocal<T> to hold the user value and define some low-level accessors. I strongly recommend using IDisposable to ensure the AsyncLocal<T> value is unset properly at the end of the scope:

public static class AsyncLocalUser
{
  private static AsyncLocal<string> _local = new AsyncLocal<string>();
  private static IDisposable Set(string newValue)
  {
    var oldValue = _local.Value;
    _local.Value = newValue;

    // I use Nito.Disposables; feel free to replace with another IDisposable implementation.
    return Disposable.Create(() => _local.Value = oldValue);
  }
  private static string Get() => _local.Value;
}

Then you can define a provider:

public static class AsyncLocalUser
{
  ... // see above
  public sealed class Provider
  {
    public IDisposable SetUser(string value) => Set(value);
  }
}

and the accessor is similarly simple:

public static class AsyncLocalUser
{
  ... // see above
  public sealed class Accessor : IUserAccessor
  {
    public string GetUser() => Get();
  }
}

You'll want to set up your DI to point IUserAccessor to AsyncLocalUser.Accessor. You can also optionally add AsyncLocalUser.Provider to your DI, or you can just create it directly.

Usage would go something like this:

foreach (var message in queue) 
{
  using (var scope = _serviceScopeFactory.CreateScope()) 
  {
    var userProvider = new AsyncLocalUser.Provider(); // (or get it from DI)
    using (userProvider.SetUser(message.User))
    {
      var payload = // create a SomeObject from the queue message
      var mylibrary = _services.GetRequiredService<MyLibrary>();
      await myLibrary.DoWorkAsync(payload);
    }
  }
}