多个 AddHostedService dotnet core

Question

When i tried to register more that one AddHostedService the method StartAsync is invoke only on the first

services.AddHostedService<HostServiceBox>(); // StartAsync is called
services.AddHostedService<HostServiceWebSocket>(); // DO NOT WORK StartAsync not called
services.AddHostedService<HostServiceLogging>(); // DO NOT WORK StartAsync not called

any idea?

Thanks for the helps

Answer 1

Below a code who work I get around the problem by creating a helper

@statup.cs

public void ConfigureServices(IServiceCollection services)
        {
            JwtBearerConfiguration(services);

            services.AddCors(options => options.AddPolicy("CorsPolicy", builder =>
            {
                builder
                    .AllowAnyMethod()
                    .AllowAnyHeader()
                    .AllowAnyOrigin()
                    .AllowCredentials();
            }));

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); ;


            services.AddSignalR();

            services.AddHostedService<HostServiceHelper>(); // <===== StartAsync is called

        }

@HostServiceHelper.cs

    public class HostServiceHelper : IHostedService
    {
        private static IHubContext<EngineHub> _hubContext;

        public HostServiceHelper(IHubContext<EngineHub> hubContext)
        {
            _hubContext = hubContext;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            return Task.Run(() =>
            {
                Task.Run(() => ServiceWebSocket(), cancellationToken);

                Task.Run(() => ServiceBox(), cancellationToken);

                Task.Run(() => ServiceLogging(), cancellationToken);

            }, cancellationToken);
        }

        public void ServiceLogging()
        {
        // your own CODE
         }

        public void ServiceWebSocket()
        {
 // your own CODE
        }

        public void ServiceBox()
        {
            // your own CODE
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            //Your logical
            throw new NotImplementedException();
        }
    }

Answer 2

A hosted service is usually a single task so I'd do it with a singleton.

// Hosted Services
services.AddSingleton<IHostedService, HttpGetCurrencyPairRequestSyncingService>();
services.AddSingleton<IHostedService, HttpPostCurrencyPairRequestSyncingService>();

And when in my class,

public class CurrencyPairCacheManagementService : BaseHostedService<CurrencyPairCacheManagementService>
        , ICurrencyPairCacheManagementService, IHostedService, IDisposable
    {
        private ICurrencyPairService _currencyPairService;
        private IConnectionMultiplexer _connectionMultiplexer;

        public CurrencyPairCacheManagementService(IConnectionMultiplexer connectionMultiplexer,
            IServiceProvider serviceProvider) : base(serviceProvider)
        {
            _currencyPairService = serviceProvider.GetService<CurrencyPairService>();
            _connectionMultiplexer = connectionMultiplexer;

            InitializeCache(serviceProvider);
        }

        /// <summary>
        /// Operation Procedure for CurrencyPair Cache Management.
        ///
        /// Updates every 5 seconds.
        ///
        /// Objectives:
        /// 1. Pull the latest currency pair dataset from cold storage (DB)
        /// 2. Cross reference checking (MemoryCache vs Cold Storage)
        /// 3. Update Currency pairs
        /// </summary>
        /// <param name="stoppingToken"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            _logger.LogInformation("CurrencyPairCacheManagementService is starting.");

            stoppingToken.Register(() => _logger.LogInformation("CurrencyPairCacheManagementService is stopping."));

            while (!stoppingToken.IsCancellationRequested)
            {
                var currencyPairs = _currencyPairService.GetAllActive();

                await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
            }

            _logger.LogWarning("CurrencyPairCacheManagementService background task is stopping.");
        }

        public void InitializeCache(IServiceProvider serviceProvider)
        {
            var currencyPairs = _currencyPairService.GetAllActive();

            // Load them individually to the cache.
            // This way, we won't have to update the entire collection if we were to remove, update or add one.
            foreach (var cPair in currencyPairs)
            {
                // Naming convention => PREFIX + CURRENCYPAIRID
                // Set the object into the cache

            }
        }

        public Task InproPair(CurrencyPair currencyPair)
        {
            throw new NotImplementedException();
        }
    }

ExecuteAsync gets hit first, before carrying on with what you want it to do. You might also want to remove the generics declaration I have because my Base class runs with generics (If you don't run your hosted service base class with generics then I don't think you'll need to inherit IHostedService and IDisposable explicitly).

Answer 3

OK, this is 2022 and .NET 6 is out. Now days it is not a problem to run multiple hosted services, as long as they are represented by different classes. Just like this:

public class Program
{
    public static void Main(string[] args)
    {
        IHost host = Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<Worker>();
                services.AddHostedService<Worker2>();
            }).Build();

        host.Run();
    }
}

Both workers will run.

But what if we need multiple instances of the same service class to run parallel? That seems to be still impossible.

I ended up implementing my own utility function to start multiple tasks in parallel and collect all the exceptions properly. Here:

/// <summary>
/// Runs multiple cancelable tasks in parallel. If any of the tasks terminates, all others are cancelled. 
/// </summary>
public static class TaskBunchRunner
{
    public class BunchException : Exception
    {
        public AggregateException Agg { get; }

        public BunchException(AggregateException agg) : base("Task bunch failed", agg)
        {
            Agg = agg;
        }

        public override string Message => $"Task bunch failed: {Agg.Message}";
        public override string ToString() => $"BunchException -> {Agg.ToString()}";
    }
    
    public static async Task Bunch(this IEnumerable<Func<CancellationToken, Task>> taskFns, CancellationToken ct)
    {
        CancellationTokenSource combinedTcs = CancellationTokenSource.CreateLinkedTokenSource(ct);
        CancellationToken ct1 = combinedTcs.Token;

        Task[] tasks = taskFns.Select(taskFn => Task.Run(() => taskFn(ct1), ct1)).ToArray();
        
        // If any of the tasks terminated, it may be because of an error or a cancellation.
        // In both cases we cancel all of them. 
        await Task.WhenAny(tasks); // this await will never throw
        combinedTcs.Cancel();
        
        var allTask = Task.WhenAll(tasks); // this will collect exceptions in an AggregateException
        try
        {
            await allTask;
        }
        catch (Exception)
        {
            if (allTask.Exception != null) throw new BunchException(allTask.Exception);
            throw; 
        }
        
        // Why not just await Task.WhenAll() and let it throw whatever it is?
        // Because await will unwrap the aggregated exception and rethrow just one of the inner exceptions,
        // losing the information about others. We want all the exceptions to be logged, that is why 
        // we get the aggregated exception from the task. We also throw it wrapped into a custom exception, so the 
        // outer await (in the caller's scope) does not unwrap it again. :facepalm:
    }
}

Now we create a single hosted service and make its ExecuteAsync method run several tasks as a bunch:

class MySingleService
{
    private readonly string _id;
    public MySingleService(string id){ _id = id;  }
    
    public async Task RunAsync(CancellationToken ct)
    {
        await Task.Delay(500, ct);
        Console.WriteLine($"Message from service {_id}");
        await Task.Delay(500, ct);
    }
}

class MyHostedService: BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        MySingleService[] individuals = new[]
        {
            new MySingleService("1"),
            new MySingleService("2"),
            new MySingleService("3"),
        };
        
        await individuals
            .Select<MySingleService, Func<CancellationToken, Task>>(s => s.RunAsync)
            .Bunch(stoppingToken);
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        IHost host = Host.CreateDefaultBuilder(args)
            .ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<MyHostedService>();
            }).Build();

        host.Run();
    }
}

Note: the TaskBunchRunner class was taken from a real project and proven to work, while the usage example is made up and not tested.

I know it is not exactly what the OP asked for. But may be useful for someone who ends up here having the same problem as I had.