When are .NET Core dependency injected instances disposed?

by

The resolved objects have the same life-time/dispose cycle as their container, that’s unless you manually dispose the transient services in code using using statement or .Dispose() method.

In ASP.NET Core you get a scoped container that’s instantiated per request and gets disposed at the end of the request. At this time, scoped and transient dependencies that were created by this container will get disposed too (that’s if they implement IDisposable interface), which you can also see on the source code here. 

public void Dispose()
{
    lock (ResolvedServices)
    {
        if (_disposeCalled)
        {
            return;
        }
        _disposeCalled = true;
        if (_transientDisposables != null)
        {
            foreach (var disposable in _transientDisposables)
            {
                disposable.Dispose();
            }

            _transientDisposables.Clear();
        }

        // PERF: We've enumerating the dictionary so that we don't allocate to enumerate.
        // .Values allocates a ValueCollection on the heap, enumerating the dictionary allocates
        // a struct enumerator
        foreach (var entry in ResolvedServices)
        {
            (entry.Value as IDisposable)?.Dispose();
        }

        ResolvedServices.Clear();
    }
}

Singletons get disposed when the parent container gets disposed, usually means when the application shuts down.

TL;DR: As long as you don’t instantiate scoped/transient services during application startup (using app.ApplicationServices.GetService<T>()) and your services correctly implement Disposable interface (like pointed in MSDN) there is nothing you need to take care of.

The parent container is unavailable outside of Configure(IApplicationBuilder app) method unless you do some funky things to make it accessible outside (which you shouldn’t anyways).

Of course, its encouraged to free up transient services as soon as possible, especially if they consume much resources.

More Related Contents:

  1. .NET Core DI, ways of passing parameters to constructor
  2. Hangfire – Multi tenant, ASP.NET Core – Resolving the correct tenant
  3. What are the costs and possible side effects of calling BuildServiceProvider() in ConfigureServices()
  4. Inject service into Action Filter
  5. Property Injection in ASP.NET Core
  6. Proper way to register HostedService in ASP.NET Core. AddHostedService vs AddSingleton
  7. Replace service registration in ASP.NET Core built-in DI container?
  8. Dependency Injection with classes other than a Controller class
  9. ASP.Net Core Call a controller from another controller
  10. Net Core Dependency Injection for Non-Controller
  11. Inversion of Control < Dependency Injection [closed]
  12. Command dotnet ef not found
  13. dotnet publish doesn´t publish correct appsettings.{env.EnvironmentName}.json
  14. Switch between dotnet core SDK versions
  15. How to extend a component with dependency injection?
  16. Meaning of bean discovery mode annotated in CDI 1.1
  17. File permissions on Linux/Unix with .NET Core
  18. How to SetBasePath in ConfigurationBuilder in Core 2.0
  19. Build .exe file in .NET Core RC2
  20. Is there a built in way of using snake case as the naming policy for JSON in ASP.NET Core 3?
  21. Include all dependencies using dotnet pack
  22. Entity Framework Core: `SqlNullValueException: Data is Null.` How to troubleshoot?
  23. Cannot find command ‘dotnet ef’
  24. How to publish environment specific appsettings in .Net core app?
  25. Should HttpClient instances created by HttpClientFactory be disposed?
  26. .NET Core app unable to start in IIS due to ErrorCode = ‘0x80004005 : 80008083
  27. How should I manage DbContext Lifetime in MVC Core?
  28. ASP.NET Core modify/substitute request body
  29. How do I handle classes with static methods with Ninject?
  30. Net Core: Execute All Dependency Injection in Xunit Test for AppService, Repository, etc

Leave a Comment