Configure/register depdency injection scoped service from within the scope

Question

I have a stateless service in Azure Service Fabric, and I'm using Microsoft.Extensions.DependencyInjection, although the same issue exists for any other DI frameworks. In my Program.cs, I create a ServiceCollection, add all (but one) of my registrations, create the service provider, and pass it to my service's constructor. Any service method with external entry will create a new service scope and call the main business logic class. The issue is that one of the classes I want to have scoped lifetime needs a value that is an input parameter on the request itself. Here's a code snippet of what I would like to achieve.

internal sealed class MyService : StatelessService, IMyService
{
    private IServiceProvider _serviceProvider;
    private IServiceScopeFactory _scopeFactory;

    public MyService(StatelessServiceContext context, IServiceProvider serviceProvider)
        : base(context)
    {
        _serviceProvider = serviceProvider;
        _scopeFactory = _serviceProvider.GetRequiredService<IServiceScopeFactory>();
    }

    public async Task<MyResponse> ProcessAsync(MyRequest request, string correlationId, CancellationToken cancellationToken)
    {
        using (var scope = _scopeFactory.CreateScope())
        {
            var requestContext = new RequestContext(correlationId);
            //IServiceCollection serviceCollection = ??;
            //serviceCollection.AddScoped<RequestContext>(di => requestContext);

            var businessLogic = scope.ServiceProvider.GetRequiredService<BusinessLogic>();
            return await businessLogic.ProcessAsync(request, cancellationToken);
        }
    }
}

The cancellation token is already passed around everywhere, including to classes that don't use it directly, just so it can be passed to dependencies that do use it, and I want to avoid doing the same with the request context.

The same issue exists in my MVC APIs. I can create middle-ware which will extract the correlation id from the HTTP headers, so the API controller doesn't need to deal with it like my service fabric service does. One way I can make it work is by giving RequestContext a default constructor, and have a mutable correlation id. However, it's absolutely critical that the correlation id doesn't get changed during a request, so I'd really like the safety of having get-only property on the context class.

My best idea at the moment is to have a scoped RequestContextFactory which has a SetCorrelationId method, and the RequestContext registration simply calls the factory to get an instance. The factory can throw an exception if a new instance is requested before the id is set, to ensure no id-less contexts are created, but it doesn't feel like a good solution.

How can I cleanly register read-only objects with a dependency injection framework, where the value depends on the incoming request?

Answer 1

I only had the idea for a RequestContextFactory as I was writing the original question, and I finally made time to test the idea out. It actually was less code than I expected, and worked well, so this will be my go-to solution now. But, the name factory is wrong. I'm not sure what to call it though.

First, define the context and factory classes. I even added some validation checks into the factory to ensure it worked the way I expect:

public class RequestContext
{
    public RequestContext(string correlationId)
    {
        CorrelationId = correlationId;
    }

    public string CorrelationId { get; }
}

public class RequestContextFactory
{
    private RequestContext _requestContext;
    private bool _used = false;

    public void SetContext(RequestContext requestContext)
    {
        if (_requestContext != null || requestContext == null)
        {
            throw new InvalidOperationException();
        }

        _requestContext = requestContext;
    }

    public RequestContext GetContext()
    {
        if (_used || _requestContext == null)
        {
            throw new InvalidOperationException();
        }

        _used = true;
        return _requestContext;
    }
}

Then, add registrations to your DI container:

services.AddScoped<RequestContextFactory>();
services.AddScoped<RequestContext>(di => di.GetRequiredService<RequestContextFactory>().GetContext());

Finally, the Service Fabric service method looks something like this

public async Task<MyResponse> ProcessAsync(MyRequest request, string correlationId, CancellationToken cancellationToken)
{
    using (var scope = _scopeFactory.CreateScope())
    {
        var requestContext = new RequestContext(correlationId);
        var requestContextFactory = scope.ServiceProvider.GetRequiredService<RequestContextFactory>();
        requestContextFactory.SetContext(requestContext);

        var businessLogic = scope.ServiceProvider.GetRequiredService<BusinessLogic>();
        return await businessLogic.ProcessAsync(request, cancellationToken);
    }
}

Kestrel middleware could look something like this

public async Task Invoke(HttpContext httpContext)
{
    RequestContext requestContext = new RequestContext(Guid.NewGuid().ToString());
    var factory = httpContext.RequestServices.GetRequiredService<RequestContextFactory>();
    factory.SetContext(requestContext);
    httpContext.Response.Headers["X-CorrelationId"] = requestContext.CorrelationId;

    await _next(httpContext);
}

Then just do the normal thing and add a RequestContext parameter to the constructor of any class that needs to get the correlation id (or any other info you put in the request context)