Using a Scoped service in a Singleton in an Asp.Net Core app

by

What you’re doing is not good and can definitely lead to issues. Since this is being done in the service registration, the scoped service is going to be retrieve once when your singleton is first injected. In other words, this code here is only going to run once for the lifetime of the service you’re registering, which since it’s a singleton, means it’s only going to happen once, period. Additionally, the context you’re injecting here only exists within the scope you’ve created, which goes away as soon as the using statement closes. As such, by the time you actually try to use the context in your singleton, it will have been disposed, and you’ll get an ObjectDisposedException.

If you need to use a scoped service inside a singleton, then you need to inject IServiceProvider into the singleton. Then, you need to create a scope and pull out your context when you need to use it, and this will need to be done every time you need to use it. For example:

public class PersistedConfigurationService : IPersistedConfigurationService
{
    private readonly IServiceProvider _serviceProvider;

    public PersistedConfigurationService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task Foo()
    {
        using (var scope = _serviceProvider.CreateScope())
        {
             var context = scope.ServiceProvider.GetRequiredService<IPersistedConfigurationDbContext>();
             // do something with context
        }
    }
}

Just to emphasize, again, you will need to do this in each method that needs to utilize the scoped service (your context). You cannot persist this to an ivar or something. If you’re put off by the code, you should be, as this is an antipattern. If you must get a scoped service in a singleton, you have no choice, but more often than not, this is a sign of bad design. If a service needs to use scoped services, it should almost invariably be scoped itself, not singleton. There’s only a few cases where you truly need a singleton lifetime, and those mostly revolve around dealing with semaphores or other state that needs to be persisted throughout the life of the application. Unless there’s a very good reason to make your service a singleton, you should opt for scoped in all cases; scoped should be the default lifetime unless you have a reason to do otherwise.

More Related Contents:

  1. How to get HttpContext.Current in ASP.NET Core? [duplicate]
  2. How should I inject a DbContext instance into an IHostedService?
  3. System.Text.Json API is there something like IContractResolver
  4. Add client certificate to .NET Core HttpClient
  5. Enable OPTIONS header for CORS on .NET Core Web API
  6. Asp.Net core long running/background task
  7. Hangfire – Multi tenant, ASP.NET Core – Resolving the correct tenant
  8. What are the costs and possible side effects of calling BuildServiceProvider() in ConfigureServices()
  9. Command dotnet ef not found
  10. How to unapply a migration in ASP.NET Core with EF Core
  11. Manipulating images with .NET Core
  12. Switch between dotnet core SDK versions
  13. How to consume a Scoped service from a Singleton?
  14. Upload files and JSON in ASP.NET Core Web API
  15. How to read values from the querystring with ASP.NET Core?
  16. ASP.NET Core appsettings.json update in code
  17. Change the JSON serialization settings of a single ASP.NET Core controller
  18. Using IConfiguration in C# Class Library
  19. File permissions on Linux/Unix with .NET Core
  20. How to SetBasePath in ConfigurationBuilder in Core 2.0
  21. Is there a built in way of using snake case as the naming policy for JSON in ASP.NET Core 3?
  22. Entity Framework Core: `SqlNullValueException: Data is Null.` How to troubleshoot?
  23. Dependency Injection with classes other than a Controller class
  24. Cannot find command ‘dotnet ef’
  25. How to get user information in DbContext using Net Core
  26. How should I manage DbContext Lifetime in MVC Core?
  27. ASP.NET Core modify/substitute request body
  28. Net Core: Execute All Dependency Injection in Xunit Test for AppService, Repository, etc
  29. What Nuget packages must be referenced by an ASP.NET Core 6 application parts project
  30. No service for type ‘Microsoft.AspNetCore.Identity.UserManager`1[Microsoft.AspNetCore.Identity.IdentityUser]’ has been registered

Leave a Comment