I need help to find a good solution to inject DBContext into Repository Services

I have new Blazor project that is sharing a common Repository module with another API project. The Repository constructors services require a DBContext instance and an AutoMapper instance. I saw that the best practices are saying that I should use IDbContextFactory<MyDBContext>. The problem is that I can't use it at the inject time into my services, so I came up with this approach that is working for now but I bet there are some downsides that I am not yet aware of them. So any help or advice would be appreciated.

        var connectionString = configuration.GetConnectionString("PAADB") ?? throw new InvalidOperationException("Connection string 'PAADB' not found.");
        services.AddDbContextFactory<MyDBContext>(options => options.UseSqlServer(connectionString), ServiceLifetime.Scoped);
        services.AddAutoMapper(Assembly.GetExecutingAssembly());

	    services.AddScoped(ConfigurePersistenceService<IUserPersistenceService, UserPersistenceService>);
        services.AddScoped(ConfigurePersistenceService<ICrmFirmsPersistenceService, CrmFirmsPersistenceService>);
        services.AddScoped(ConfigurePersistenceService<ICrmAdvisorsPersistenceService, CrmAdvisorsPersistenceService>);


        .......


	    static I ConfigurePersistenceService<I, T>(IServiceProvider provider) where T : class
        {
            var db = provider.GetRequiredService<IDbContextFactory<MyDBContext>>();
            var autoMapper = provider.GetRequiredService<IMapper>();
            return (I)Activator.CreateInstance(typeof(T), db.CreateDbContext(), autoMapper);
        }//ConfigurePersistenceService - special way to pass db instance

Repository service example

public class CrmFirmsPersistenceService : PersistenceService<CrmFirm>, ICrmFirmsPersistenceService
{
    private readonly IMapper _mapper;

    public CrmFirmsPersistenceService(MyDBContext context, IMapper mapper) : base(context)
    {
        _mapper = mapper;
    }

    public async Task<(IEnumerable<CrmFirmDTO>, int)> GetFirmsWithPagination(int pageNumber, int pageSize)
    {
        var baseQuery = _context.CrmFirms;

        var lstItems = await baseQuery.OrderByDescending(x => x.Id).Skip((pageNumber) * pageSize).Take(pageSize).ToListAsync();
        var total = baseQuery.Count();            
        return (_mapper.Map<IEnumerable<CrmFirmDTO>>(lstItems), total);
    }
}

}

Exceptions that I get from time to time:

A second operation was started on this context instance before a previous operation completed. This is usually caused by different threads concurrently using the same instance of DbContext. For more information on how to avoid threading issues with DbContext, see https://go.microsoft.com/fwlink/?linkid=2097913.

> I saw that the best practices are saying that I should use IDbContextFactory<MyDBContext>

That's not a "best practice", in fact, in this case, it's a problem.

The actual problem that needs solving is that the DI scope in a Blazor Server application is the entire user session. There are many options available if we need scope semantics, and a specialized factory is only one of them. In fact, DbContextFactory is only meant to generate user-managed DbContext instances. It's not meant to control the lifetime of wrappers or dependent objects.

DbContextFactory - user managed scope

A DbContextFactory is meant to be used when we want to explicitly manage the scope of a DbContext only, eg at the function level. It only creates a DbContext, it doesn't dispose it. This is evident in the documentation examples :

@inject IDbContextFactory<ContactContext> DbFactory

private async Task DeleteContactAsync()
{
    using var context = DbFactory.CreateDbContext();
    ...
}

This makes it a bad fit for CrmFirmsPersistenceService. At the very least, the service's callers should explicitly dispose the service so it can dispose the DbContext instance in turn.

Component scope

One way to solve the problem is to limit the service scope to a component's lifetime. This can be done by inheriting from OwningComponentBase.

In this documentation example, AppDbContext is scoped to the component's lifetime. It's accessible through the Service property :

@page "/users"
@attribute [Authorize]
@inherits OwningComponentBase<AppDbContext>

<h1>Users (@Service.Users.Count())</h1>

<ul>
    @foreach (var user in Service.Users)
    {
        <li>@user.UserName</li>
    }
</ul>

In the question's case, this would work without requiring a context factory or activator, simply by registering the DbContexts and CrmFirmsPersistenceService et al as scoped services.

The DI configuration could be :

services.AddDbContext<MyDBContext>(options => options.UseSqlServer(connectionString));
services.AddAutoMapper(Assembly.GetExecutingAssembly());
services.AddScoped<ICrmFirmsPersistenceService, CrmFirmsPersistenceService>();

The component itself would need to inherit from OwningComponentBase<T>

@page "/firms"
@inherits OwningComponentBase<ICrmFirmsPersistenceService>

<h1>Firms (@page.count)</h1>

<ul>
    @foreach (var firm in page.firms)
    {
        ...
    }
</ul>

@code {

    (IEnumerable<CrmFirmDTO> firms, int count) page = null!;
    protected override async Task OnInitializedAsync()
    {
        page = await Service.GetFirmsWithPagination();
    }

Explicit Scope

When we want to define a finer scope, we need to create it explicitly with IServiceProvider.CreateScope and create services using that scope. That's how singleton Hosted Services can consume scoped services.

To do this, we need to add IServiceProvider as a dependency to the component:

@page "/firms"
@inject IServiceProvider Services

Then, when we need to create an ICrmFirmsPersistenceService scoped instance, we need to do so through an explicit scope:

using var scope=Services.CreateScope();
var firmsService=scope.GetRequiredService<ICrmFirmsPersistenceService>();
...

When that scope gets disposed, any scoped serviced created through it will also get disposed, including the CrmFirmsPersistenceService and its DbContext