CODEWITHSUNDEEP
asp.net-coredependency-injection
Michael Kropat
Michael Kropat

Reputation: 15227

How to inject a reference to a specific IHostedService implementation?

My web app has a background service that listens to a service bus. Based on the docs, it looks like the built-in way to run a background service is to implement IHostedService.

So I have some code that looks like this:

public class ServiceBusListener : IMessageSource<string>, IHostedService
{
    public virtual event ServiceBusMessageHandler<string> OnMessage = delegate { };

    public Task StartAsync(CancellationToken cancellationToken)
    {
        // run the background task...
    }

    // ... other stuff ...
}

The service is then registered in Startup.cs with:

services.AddSingleton<IHostedService, ServiceBusListener>();

Once I update to ASP.NET 2.1 I can use the new convenience method:

services.AddHostedService<ServiceBusListener>();

But I believe the two are functionally equivalent.

The complication: my web app has multiple implementations of IHostedService (specifically, different instances of service bus listeners).

The question: how can I have some other component get a reference to a specific hosted service implementation (my service bus listener)? In other words, how do I get a specific instance injected into a component?

Use case: my background service listens for service bus messages and then re-publishes messages as .NET events (in case you're wondering, the consuming code deals with the threading issues). If the event is on the background service, then subscribers need to get a reference to the background service to be able to subscribe.

What I've tried: if I do the obvious thing and declare ServiceBusListener as a dependency to be injected into a different component, my startup code throws a "Could not resolve a service of type" exception.

Is it even possible to request a specific implementation of a IHostedService? If not, what's the best workaround? Introduce a third component that both my service and the consumer can reference? Avoid IHostedService and run the background service manually?

Upvotes: 29

Views: 20465

Answers (7)

Aislan Gelatti Rocha
Aislan Gelatti Rocha

Reputation: 71

You can use BackgroundService and reflection to achieve what you need! First thing is to define your background service

public class MyHostedService : BackgroundService
{
    // Implement your method to execute the task you want
    protected override async Task ExecuteAsync(CancellationToken cancellationToken) 
    {
        // do your stuff
    }
}

Then, inject your backgroundService in your Program.cs class

services.AddHostedService<>(MyHostedService);

Finally - using a controller as example - use reflection to get your specific background service among all IHostedServices eventually injected

public class MyController : BaseController
{
    private readonly IHostedService MyService;

    public MyController(IEnumerable<IHostedService> hostedServices)
    {
        MyService = hostedServices.First(x => x
            .GetType().UnderlyingSystemType.Name
            .Equals(nameof(MyHostedService)))

        // now you can call MyService.StartAsync(new CancellationToken) to restart you background service
    }
}

Upvotes: 0

ygoe
ygoe

Reputation: 20414

Thank you for the answer, Michael, it works well. Strange that we need such hacks to make dependency injection actually work.

I've changed your class so that you don't need the service locator. Generics help here.

public class BackgroundServiceStarter<T> : IHostedService
    where T : IHostedService
{
    private readonly T backgroundService;

    public BackgroundServiceStarter(T backgroundService)
    {
        this.backgroundService = backgroundService;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        return backgroundService.StartAsync(cancellationToken);
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        return backgroundService.StopAsync(cancellationToken);
    }
}

Upvotes: 10

MDR
MDR

Reputation: 311

.net core now has a AddHostedService overload that lets you specify a factory function/method for resolving hosted services. This lets you specify your hosted service as a singleton and then inject it where necessary.

Documentation says it's been available since .Net Core 3.x

Arguably, one should analyze the architecture choices that led to this path to ensure that this route is actually required. But sometimes it may be necessary.

AddHostedService<THostedService>(IServiceCollection, Func<IServiceProvider,THostedService>)

Usage is

services
   .AddSingleton<IMyServiceContract, MyServiceImplementation>()
   .AddHostedService(services => (MyServiceImplementation) services.GetService<IMyServiceContract>())
;

If your IServiceContract inherits from IHostedService or you don't use an interface then the cast is unnecessary.

Upvotes: 11

jjxtra
jjxtra

Reputation: 21170

None of the complexity in the other answers is needed as of .net core 3.1. If you don't need to get a concrete reference to your class from another class, simply call:

services.AddHostedService<MyHostedServiceType>();

If you must have a concrete reference, do the following:

services.AddSingleton<IHostedService, MyHostedServiceType>();

Upvotes: 5

Sunib
Sunib

Reputation: 332

My little helper code in response to the excellent answer of jjxtra

    /// <summary>
    /// Instead of calling service.AddHostedService<T> you call this make sure that you can also access the hosted service by interface TImplementation
    /// https://stackoverflow.com/a/64689263/619465
    /// </summary>
    /// <param name="services">The service collection</param>
    public static void AddInjectableHostedService<TService, TImplementation>(this IServiceCollection services)
        where TService : class
        where TImplementation : class, IHostedService, TService
    {
        services.AddSingleton<TImplementation>();
        services.AddSingleton<IHostedService>(provider => provider.GetRequiredService<TImplementation>());
        services.AddSingleton<TService>(provider => provider.GetRequiredService<TImplementation>());
    }

So this will allow you to register your IHostedService with

        services
            .AddInjectableHostedService<IExposeSomething, MyHostedServiceType>();

Where MyHostedServiceType off course implements some interface (IExposeSomething) with things that you want to expose to other types.

Upvotes: 3

sroll
sroll

Reputation: 782

Based on your answers, I made a helpful extension method. It allows to register an IHostedService with another interface.

The other interface doesn't need to implement IHostedService, so you don't expose the StartAsync() and StopAsync() methods

public static class ServiceCollectionUtils
{
    public static void AddHostedService<TService, TImplementation>(this IServiceCollection services)
        where TService : class
        where TImplementation : class, IHostedService, TService
    {
        services.AddSingleton<TService, TImplementation>();
        services.AddHostedService<HostedServiceWrapper<TService>>();
    }

    private class HostedServiceWrapper<TService> : IHostedService
    {
        private readonly IHostedService _hostedService;

        public HostedServiceWrapper(TService hostedService)
        {
            _hostedService = (IHostedService)hostedService;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            return _hostedService.StartAsync(cancellationToken);
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return _hostedService.StopAsync(cancellationToken);
        }
    }
}

Upvotes: 16

Michael Kropat
Michael Kropat

Reputation: 15227

Turns out there's an easy way to do this (thanks for the pointer, Steven).

If you need to be able to inject / get a reference to some service, go ahead and register the service normally (without worrying about any IHostedService stuff):

services.AddSingleton<ServiceBusListener>();

Now we can register a separate hosted service whose only responsibility is to start/stop the service we just registered:

services.AddHostedService<BackgroundServiceStarter<ServiceBusListener>>();

Where BackgroundServiceStarter is a helper class that looks something like:

public class BackgroundServiceStarter<T> : IHostedService where T:IHostedService
{
    readonly T backgroundService;

    public BackgroundServiceStarter(T backgroundService)
    {
        this.backgroundService = backgroundService;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        return backgroundService.StartAsync(cancellationToken);
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        return backgroundService.StopAsync(cancellationToken);
    }
}

Update 2018/8/6: updated code to avoid service locator pattern thanks to a suggestion from ygoe

Upvotes: 40

Related Questions