Update autofac container from IHostedService asynchronously on app startup

I am having an ASP.net core 3.0 app and I want to see if I can register some of my Orleans Cluster Clients asynchronously on app startup, due to the fact the creation and making the connections to Orleans Cluster are heavy. According to this article I created my own IHostedService, but when I implemented startAsync method I am not sure how to get the autofac container which I am using in Startup.cs and update it with my clients registrations. I have read this but see my below code, still I don't see the clients are getting registered. Is it doable or am I missing anything here? thanks!

Startup.cs

...
public static IServiceProvider ConfigureServices(IServiceCollection services)
{
    var coreBuilder = new ContainerBuilder();
    
    // other autofac registrations...

    services.AddHostedService<MyService>();
    coreBuilder.populate(services);

    var container = coreBuilder.Build();

    var serviceProvider = new AutofacServiceProvider(container);
    return serviceProvider;
}

MyService.cs

public MyService : IHostedService
{
    private readonly IServiceProvider _serviceProvider;
    public MyService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // get the autofac container from Startup.cs and update with cluster client registrations? 
        using(var scope = this._serviceProvider.GetRequiredService<ILifeTimeScope>()
.BeginLifeTimeScope(builder => do registration here...)) {}
    }

    // noop
    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

Solution

You cannot update the DI container on-the-fly like that. Once it's built, it's built.

You have another option: make a factory class that caches the clients, initialize them in the background, then retrieve them from the factory.

class MyService
{
    // ...   
}

class MyServiceFactory
{
    private ConcurrentDictionary<string, MyService> _instances = new ConcurrentDictionary<string, MyService>();

    public async Task<MyService> CreateAsync(string key)
    {
        if (_instances.TryGetValue(key, out var service))
        {
            return service;
        }

        // perform expensive initialization
        // ...
        service = new MyService();

        _instances[key] = service;
        return service;
    }
}

class MyServiceInitializer: BackgroundService
{
    private MyServiceFactory _serviceFactory;

    public MyServiceInitializer(MyServiceFactory serviceFactory)
    {
        _serviceFactory = serviceFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await _serviceFactory.CreateAsync("first instance");
        await _serviceFactory.CreateAsync("second instance");
    }
}

services.AddSingleton<MyServiceFactory>();
services.AddHostedService<MyServiceInitializer>();

Then resolve an instance you need. It will resolve instantly, because it's been initialized in the background.

class MyController
{
    private MyServiceFactory _serviceFactory;

    public MyController(MyServiceFactory serviceFactory)
    {
        _serviceFactory = serviceFactory;
    }

    [HttpGet]
    public async Task<ActionResult> Index()
    {
        var service = await _serviceFactory.CreateAsync("first instance");
        // use the service
    }
}