BackgroundService and Service Lifetime .Net

Need some help to see what's the "correct" approach to tackle this problem.

So I have this application that starts a background service that's always running and checking for arrival of data.
When some data arrives it'll be written to a local db, with the help with a helper service, the only requirement it's to use LiteDb.

So in normal conditions this was a simple task.

But using the LiteDb created a problem.

When I register the service that will do the work of writing to the db along other things, I need to pass an instance of LiteDb.

The only problem it's that using this approach the LiteDb stays open all the time with an extra file (log), file that looks to me that's kind of transactions or whatever... After reading the documentation the only way to "commit" everything to the db file it's disposing the LiteDb object, so using this approach it's not possible, because the service is glued to the background service, and it's indifferent to set the lifetime of the service...

So my main problem it's that I need to dispose the object in the service after it's been used.

So how to handle this kind of situation?

Newing the LiteDb inside the service, with a specific method for that?
Remove from the constructor and inject by method, and wrapping the service call with the using?

Any other option?

Thanks

You probably want to use either IServiceScopeFactory or IScopedProcessingService:

https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.dependencyinjection.iservicescopefactory

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/host/hosted-services#consuming-a-scoped-service-in-a-background-task

Injecting IServiceScopeFactory as a constructor parameter into your background service, you can use it to generate scopes to resolve services and perform actions which can then be disposed of in between cycles. IScopedProcessingService works similarly.

public class MyBackgroundService : BackgroundService
    {
        private readonly IServiceScopeFactory _scopeFactory;
        private readonly ILogger _logger;

        public MyBackgroundService(IServiceScopeFactory scopeFactory, ILogger<MyBackgroundService> logger)
        {
            _logger = logger;
            _scopeFactory = scopeFactory;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                using (var scope = _scopeFactory.CreateScope())
                {
                    var dependencyOne = scope.ServiceProvider.GetRequiredService<IFirstDependency>();
                    var dependencyTwo = scope.ServiceProvider.GetRequiredService<ISecondDependency>();
                    // do work
                }
                await Task.Delay(5000, stoppingToken);
            }
        }
    }