Proper way to register HostedService in ASP.NET Core. AddHostedService vs AddSingleton

Question

What is the proper way to register a custom hosted service in ASP.NET Core 2.1? For example, I have a custom hosted service derived from BackgroundService named MyHostedService. How should I register it?

public IServiceProvider ConfigureServices(IServiceCollection services)
{           
    //...
    services.AddSingleton<IHostedService, MyHostedService>();
}

or

public IServiceProvider ConfigureServices(IServiceCollection services)
{           
    //...
    services.AddHostedService<MyHostedService>();
}

?

Here we can see the first case, but here there is a second case.

Are these methods equal?

Are they equal the seconds one call the first one internally but as Transient, not singleton — Nkosi
– Nkosi, Commented Jul 23, 2018 at 13:54
It's more than which one is singleton and which isn't. Hosted services get special treatment from the runtime through their StartAsync, StopAsync methods. Using scoped/transient objects is possible by using scopes — Panagiotis Kanavos
– Panagiotis Kanavos, Commented Jul 23, 2018 at 14:26

Panagiotis Kanavos · Accepted Answer · 2021-01-19 08:50:07Z

70

Update

In the past, a HostedService was a long-lived transient, effectively acting as a singleton. Since .NET Core 3.1 it's an actual Singleton.

Use AddHostedService

A hosted service is more than just a singleton service. The runtime "knows" about it, can tell it to start by calling StartAsync or stop by calling StopAsync() whenever eg the application pool is recycled. The runtime can wait for the hosted service to finish before the web application itself terminates.

As the documentation explains a scoped service can be consumed by creating a scope inside the hosted service's worker method. The same holds for transient services.

To do so, an IServicesProvider or an IServiceScopeFactory has to be injected in the hosted service's constructor and used to create the scope.

Borrowing from the docs, the service's constructor and worker method can look like this:

public IServiceProvider Services { get; }

public ConsumeScopedServiceHostedService(IServiceProvider services, 
    ILogger<ConsumeScopedServiceHostedService> logger)
{
    Services = services;
    _logger = logger;
}


private void DoWork()
{
    using (var scope = Services.CreateScope())
    {
        var scopedProcessingService = 
            scope.ServiceProvider
                .GetRequiredService<IScopedProcessingService>();

        scopedProcessingService.DoWork();
    }
}

This related question shows how to use a transient DbContext in a hosted service:

public class MyHostedService : IHostedService
{
    private readonly IServiceScopeFactory scopeFactory;

    public MyHostedService(IServiceScopeFactory scopeFactory)
    {
        this.scopeFactory = scopeFactory;
    }

    public void DoWork()
    {
        using (var scope = scopeFactory.CreateScope())
        {
            var dbContext = scope.ServiceProvider.GetRequiredService<MyDbContext>();
            …
        }
    }
    …
}

edited Jan 19, 2021 at 8:50

answered Jul 23, 2018 at 14:25

Panagiotis Kanavos

134k16 gold badges211 silver badges271 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

kayjtea Over a year ago

Minor correction: a hosted service is not, in fact, a singleton service. You can call AddHostedService as many times as you want for some concrete class. The runtime will start up multiple instances of the service. This can be used with BackgroundService to set up a worker pool, for instance.

Panagiotis Kanavos Over a year ago

@kayjtea I wasn't implying it is, I was answering the question. But it looks like hosted services are singletons now

xSx Over a year ago

Does it work the same now? Will it be possible to do it through Factory and ActivatorUtilites.CreateInstance?

Marco Pelegrini Over a year ago

Using hosted services as a way to add an activated singleton is a very bad practice, please don't do this. Use github.com/dotnet/extensions/tree/main/src/Libraries/…

Panagiotis Kanavos Over a year ago

What are you referring to? Hosted services do stuff in the background, they aren't just singletons instantiated at startup

Pang · Accepted Answer · 2021-09-09 08:28:10Z

35

Update

Somewhere between .Net Core 2.2 and 3.1 the behavior has changed, AddHostedService is now adding a Singleton instead of the previous Transient service. Credit - Comment by LeonG

public static class ServiceCollectionHostedServiceExtensions
{
    /// <summary>
    /// Add an <see cref="IHostedService"/> registration for the given type.
    /// </summary>
    /// <typeparam name="THostedService">An <see cref="IHostedService"/> to register.</typeparam>
    /// <param name="services">The <see cref="IServiceCollection"/> to register with.</param>
    /// <returns>The original <see cref="IServiceCollection"/>.</returns>
    public static IServiceCollection AddHostedService<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] THostedService>(this IServiceCollection services)
        where THostedService : class, IHostedService
    {
        services.TryAddEnumerable(ServiceDescriptor.Singleton<IHostedService, THostedService>());

        return services;
    }

    /// <summary>
    /// Add an <see cref="IHostedService"/> registration for the given type.
    /// </summary>
    /// <typeparam name="THostedService">An <see cref="IHostedService"/> to register.</typeparam>
    /// <param name="services">The <see cref="IServiceCollection"/> to register with.</param>
    /// <param name="implementationFactory">A factory to create new instances of the service implementation.</param>
    /// <returns>The original <see cref="IServiceCollection"/>.</returns>
    public static IServiceCollection AddHostedService<THostedService>(this IServiceCollection services, Func<IServiceProvider, THostedService> implementationFactory)
        where THostedService : class, IHostedService
    {
        services.TryAddEnumerable(ServiceDescriptor.Singleton<IHostedService>(implementationFactory));

        return services;
    }
}

Reference ServiceCollectionHostedServiceExtensions

Original Answer

They are similar but not completely

AddHostedService is part of Microsoft.Extensions.Hosting.Abstractions.

It belongs to Microsoft.Extensions.Hosting.Abstractions in the ServiceCollectionHostedServiceExtensions class

using Microsoft.Extensions.Hosting;

namespace Microsoft.Extensions.DependencyInjection
{
    public static class ServiceCollectionHostedServiceExtensions
    {
        /// <summary>
        /// Add an <see cref="IHostedService"/> registration for the given type.
        /// </summary>
        /// <typeparam name="THostedService">An <see cref="IHostedService"/> to register.</typeparam>
        /// <param name="services">The <see cref="IServiceCollection"/> to register with.</param>
        /// <returns>The original <see cref="IServiceCollection"/>.</returns>
        public static IServiceCollection AddHostedService<THostedService>(this IServiceCollection services)
            where THostedService : class, IHostedService
            => services.AddTransient<IHostedService, THostedService>();
    }
}

Note it is using Transient life time scope and not Singleton

Internally the framework add all the hosted services to another service (HostedServiceExecutor)

public HostedServiceExecutor(ILogger<HostedServiceExecutor> logger, 
    IEnumerable<IHostedService> services) //<<-- note services collection
{
    _logger = logger;
    _services = services;
}

at startup that is a singleton via the WebHost Constructor.

_applicationServiceCollection.AddSingleton<HostedServiceExecutor>();

edited Sep 9, 2021 at 8:28

Pang

10.2k146 gold badges87 silver badges126 bronze badges

answered Jul 23, 2018 at 13:59

Nkosi

249k38 gold badges472 silver badges506 bronze badges

10 Comments

Denis Babarykin Over a year ago

It means, that despite the fact that the service is registered as scoped inside AddHostedService, his lifetime will be as long, as application lifetime, right?

johnny 5 Over a year ago

@Nkosi, how are transient services added to a singleton, shouldn't the Dependency injector throw in that case?

Nkosi Over a year ago

@DenisBabarykin yes that would be accurate.

Nkosi Over a year ago

@johnny5 scoped is special. a singleton can still call a transient lifetime dependency. Technically the transient becomes a singleton itself as the instance will live in the singleton.

LeonG Over a year ago

Somewhere between .Net Core 2.2 and 3.1 the behavior has changed, AddHostedService is now adding a Singleton instead of the previous Transient service.

|

Christian Davén · Accepted Answer · 2022-11-09 14:38:14Z

26

One huge difference is that AddSingleton() is lazy while AddHostedService() is eager.

A service added with AddSingleton() will be instantiated the first time it is injected into a class constructor. This is fine for most services, but if it really is a background service you want, you probably want it to start right away.

A service added with AddHostedService() will be instantiated immediately, even if no other class will ever want it injected into its constructor. This is typical for background services, that run all the time.

Also, it seems that you cannot inject a service added with AddHostedService() into another class.

answered Nov 9, 2022 at 14:38

Christian Davén

18.6k13 gold badges71 silver badges79 bronze badges

4 Comments

Erik Westwig Over a year ago

Your last sentence was key for me. I find it rather inconvenient that you can't DI a hosted service into another class!

David Graham Over a year ago

@ErikWestwig You just have to wrap it in a scope. Include IServiceProvider services to constructor and services.CreateScope

stephen Over a year ago

@DavidGraham, can you elaborate? I'm experiencing the same frustration as Erik. I want to create a master service that governs application lifecycle (hence must be derived from IHostedService and added with AddHostedService) but is also available to controllers (hence must be derived from IMasterService and added with AddSingleton).

David Graham Over a year ago

@stephen How about adding the service as you would with AddHostedService but create an interface that you can get from the scope. Your controllers can have access to the IWorkerController. You create that controller interface to do what you need but if you inject it into the worker and you controllers they all can use it.

Sandy · Accepted Answer · 2024-05-08 02:01:26Z

6

One major difference is that AddSingleton() will allow the creation of multiple instances of the same background service whereas AddHostedService() will ignore duplicates.

One use-case where it is useful to have multiple instances of the same background service is if you want to have multiple workers pulling work from a queue. Here is an example of how to create multiple instances of the same background service:

for (int i = 0; i < workerCount; i++)
{
    services.AddSingleton<IHostedService, WorkerBackgroundService>();
}

answered May 8, 2024 at 2:01

Sandy

1,5842 gold badges20 silver badges37 bronze badges

Comments

user3518628 · Accepted Answer · 2025-02-24 16:45:31Z

3

I've had the same problem and I solved it by first registering the service as singleton, then using another overload of AddHostedService I could retrieve my already registered service from DI:

services.AddSingleton<MyService>();
services.AddHostedService(sp => sp.GetRequiredService<MyService>());

answered Feb 24 at 16:45

user3518628

312 bronze badges

Collectives™ on Stack Overflow

Proper way to register HostedService in ASP.NET Core. AddHostedService vs AddSingleton

5 Answers 5

5 Comments

Update

Original Answer

10 Comments

4 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

5 Comments

Update

Original Answer

10 Comments

4 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related