Add the ability to start and stop IHostedService instances concurrently

src/libraries/Microsoft.Extensions.Hosting/ref/Microsoft.Extensions.Hosting.cs

@@ -114,6 +114,8 @@ public partial class HostOptions
  {
  public HostOptions() { }
  public Microsoft.Extensions.Hosting.BackgroundServiceExceptionBehavior BackgroundServiceExceptionBehavior { get { throw null; } set { } }
+ public bool ServicesStartConcurrently { get { throw null; } set { } }
+ public bool ServicesStopConcurrently { get { throw null; } set { } }
  public System.TimeSpan ShutdownTimeout { get { throw null; } set { } }
  }
 }

src/libraries/Microsoft.Extensions.Hosting/src/HostOptions.cs

@@ -17,6 +17,16 @@ public class HostOptions
  /// </summary>
  public TimeSpan ShutdownTimeout { get; set; } = TimeSpan.FromSeconds(30);
 
+ /// <summary>
+ /// Determines if the <see cref="IHost"/> will start registered instances of <see cref="IHostedService"/> concurrently or sequentially
+ /// </summary>
+ public bool ServicesStartConcurrently { get; set; }
+
+ /// <summary>
+ /// Determines if the <see cref="IHost"/> will stop registered instances of <see cref="IHostedService"/> concurrently or sequentially
+ /// </summary>
+ public bool ServicesStopConcurrently { get; set; }
+
  /// <summary>
  /// The behavior the <see cref="IHost"/> will follow when any of
  /// its <see cref="BackgroundService"/> instances throw an unhandled exception.
@@ -30,11 +40,25 @@ public class HostOptions
  internal void Initialize(IConfiguration configuration)
  {
  var timeoutSeconds = configuration["shutdownTimeoutSeconds"];
- if (!string.IsNullOrEmpty(timeoutSeconds)
+ if (!string.IsNullOrWhiteSpace(timeoutSeconds)
  && int.TryParse(timeoutSeconds, NumberStyles.None, CultureInfo.InvariantCulture, out var seconds))
  {
  ShutdownTimeout = TimeSpan.FromSeconds(seconds);
  }
+
+ var servicesStartConcurrently = configuration["servicesStartConcurrently"];
+ if (!string.IsNullOrWhiteSpace(servicesStartConcurrently)
+ && bool.TryParse(servicesStartConcurrently, out bool startBehavior))
+ {
+ ServicesStartConcurrently = startBehavior;
+ }
+
+ var servicesStopConcurrently = configuration["servicesStopConcurrently"];
+ if (!string.IsNullOrWhiteSpace(servicesStopConcurrently)
+ && bool.TryParse(servicesStopConcurrently, out bool stopBehavior))
+ {
+ ServicesStopConcurrently = stopBehavior;
+ }
  }
  }
 }

src/libraries/Microsoft.Extensions.Hosting/src/Internal/Host.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
@@ -65,14 +66,63 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
  combinedCancellationToken.ThrowIfCancellationRequested();
  _hostedServices = Services.GetRequiredService<IEnumerable<IHostedService>>();
 
- foreach (IHostedService hostedService in _hostedServices)
+ List<Exception> exceptions = new List<Exception>();
+
+ if (_options.ServicesStartConcurrently)
+ {
+ Task tasks = Task.WhenAll(_hostedServices.Select(async service =>
+ {
+ await service.StartAsync(combinedCancellationToken).ConfigureAwait(false);
+
+ if (service is BackgroundService backgroundService)
+ {
+ _ = TryExecuteBackgroundServiceAsync(backgroundService);
+ }
+ }));
+
+ try
+ {
+ await tasks.ConfigureAwait(false);
+ }
+ catch (Exception ex)
+ {
+ exceptions.AddRange(tasks.Exception?.InnerExceptions?.ToArray() ?? new[] { ex });
+ }
+ }
+ else
  {
- // Fire IHostedService.Start
- await hostedService.StartAsync(combinedCancellationToken).ConfigureAwait(false);
+ foreach (IHostedService hostedService in _hostedServices)
+ {
+ try
+ {
+ // Fire IHostedService.Start
+ await hostedService.StartAsync(combinedCancellationToken).ConfigureAwait(false);
+
+ if (hostedService is BackgroundService backgroundService)
+ {
+ _ = TryExecuteBackgroundServiceAsync(backgroundService);
+ }
+ }
+ catch (Exception ex)
+ {
+ exceptions.Add(ex);
+ }
+ }
+ }
 
- if (hostedService is BackgroundService backgroundService)
+ if (exceptions.Count > 0)
+ {
+ if (exceptions.Count == 1)
  {
- _ = TryExecuteBackgroundServiceAsync(backgroundService);
+ // Rethrow if it's a single error
+ _logger.HostedServiceStartupFaulted(exceptions[0]);
+ ExceptionDispatchInfo.Capture(exceptions[0]).Throw();
+ }
+ else
+ {
+ var ex = new AggregateException("One or more hosted services failed to start.", exceptions);
+ _logger.HostedServiceStartupFaulted(ex);
+ throw ex;
  }
  }
 
@@ -125,18 +175,37 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
  // Trigger IHostApplicationLifetime.ApplicationStopping
  _applicationLifetime.StopApplication();
 
- IList<Exception> exceptions = new List<Exception>();
- if (_hostedServices != null) // Started?
+ List<Exception> exceptions = new List<Exception>();
+ if (_hostedServices?.Any() == true) // Started?
  {
- foreach (IHostedService hostedService in _hostedServices.Reverse())
+ // Ensure hosted services are stopped in FILO order
+ IEnumerable<IHostedService> hostedServices = _hostedServices.Reverse();
+
+ if (_options.ServicesStopConcurrently)
  {
+ Task tasks = Task.WhenAll(hostedServices.Select(async service => await service.StopAsync(token).ConfigureAwait(false)));
+
  try
  {
- await hostedService.StopAsync(token).ConfigureAwait(false);
+ await tasks.ConfigureAwait(false);
  }
  catch (Exception ex)
  {
- exceptions.Add(ex);
+ exceptions.AddRange(tasks.Exception?.InnerExceptions?.ToArray() ?? new[] { ex });
+ }
+ }
+ else
+ {
+ foreach (IHostedService hostedService in hostedServices)
+ {
+ try
+ {
+ await hostedService.StopAsync(token).ConfigureAwait(false);
+ }
+ catch (Exception ex)
+ {
+ exceptions.Add(ex);
+ }
  }
  }
  }
@@ -155,9 +224,18 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
 
  if (exceptions.Count > 0)
  {
- var ex = new AggregateException("One or more hosted services failed to stop.", exceptions);
- _logger.StoppedWithException(ex);
- throw ex;
+ if (exceptions.Count == 1)
+ {
+ // Rethrow if it's a single error
+ _logger.HostedServiceStartupFaulted(exceptions[0]);
+ ExceptionDispatchInfo.Capture(exceptions[0]).Throw();
+ }
+ else
+ {
+ var ex = new AggregateException("One or more hosted services failed to stop.", exceptions);
+ _logger.HostedServiceStartupFaulted(ex);
+ throw ex;
+ }
  }
  }
 

src/libraries/Microsoft.Extensions.Hosting/src/Internal/HostingLoggerExtensions.cs

@@ -101,5 +101,16 @@ public static void BackgroundServiceStoppingHost(this ILogger logger, Exception?
  message: SR.BackgroundServiceExceptionStoppedHost);
  }
  }
+
+ public static void HostedServiceStartupFaulted(this ILogger logger, Exception? ex)
+ {
+ if (logger.IsEnabled(LogLevel.Error))
+ {
+ logger.LogError(
+ eventId: LoggerEventIds.HostedServiceStartupFaulted,
+ exception: ex,
+ message: "Hosting failed to start");
+ }
+ }
  }
 }

src/libraries/Microsoft.Extensions.Hosting/src/Internal/LoggerEventIds.cs

@@ -17,5 +17,6 @@ internal static class LoggerEventIds
  public static readonly EventId ApplicationStoppedException = new EventId(8, nameof(ApplicationStoppedException));
  public static readonly EventId BackgroundServiceFaulted = new EventId(9, nameof(BackgroundServiceFaulted));
  public static readonly EventId BackgroundServiceStoppingHost = new EventId(10, nameof(BackgroundServiceStoppingHost));
+ public static readonly EventId HostedServiceStartupFaulted = new EventId(11, nameof(HostedServiceStartupFaulted));
  }
 }

src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/HostTests.cs

@@ -16,8 +16,10 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Configuration.UserSecrets;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Moq;
 using Xunit;
 
 namespace Microsoft.Extensions.Hosting.Tests
@@ -36,6 +38,114 @@ public async Task StopAsyncWithCancellation()
  await host.StopAsync(cts.Token);
  }
 
+ public static IEnumerable<object[]> StartAsync_StopAsync_Concurrency_TestCases
+ {
+ get
+ {
+ foreach (bool stopConcurrently in new[] { true, false })
+ foreach (bool startConcurrently in new[] { true, false })
+ foreach (int hostedServiceCount in new[] { 0, 1, 10 })
+ {
+ yield return new object[] { stopConcurrently, startConcurrently, hostedServiceCount };
+ }
+ }
+ }
+ [Theory]
+ [MemberData(nameof(StartAsync_StopAsync_Concurrency_TestCases))]
+ public async Task StartAsync_StopAsync_Concurrency(bool stopConcurrently, bool startConcurrently, int hostedServiceCount)
+ {
+ var startExecutionCount = 0;
+ var startCallOrder = 0;
+
+ var stopCallOrder = hostedServiceCount;
+ var stopExecutionCount = 0;
+
+ var hostedServices = new Mock<IHostedService>[hostedServiceCount];
+
+ for (int i = 0; i < hostedServiceCount; i++)
+ {
+ var index = i;
+ var service = new Mock<IHostedService>();
+ service.Setup(y => y.StopAsync(It.IsAny<CancellationToken>()))
+ .Callback(() =>
+ {
+ // Ensures that IHostedService instances are stopped in FILO order
+ Assert.Equal(index, --stopCallOrder);
+ })
+ .Returns(async () =>
+ {
+ if (stopConcurrently && hostedServiceCount > 1)
+ {
+ // Basically this will force all IHostedService instances to have StopAsync called before any one completes
+ stopExecutionCount++;
+ int waitCount = 0;
+
+ while (stopExecutionCount < hostedServiceCount && waitCount++ < 20)
+ {
+ await Task.Delay(10).ConfigureAwait(false);
+ }
+
+ // This will ensure that we truly are stopping all services asynchronously
+ Assert.Equal(hostedServiceCount, stopExecutionCount);
+ }
+ })
+ .Verifiable();
+
+ service.Setup(y => y.StartAsync(It.IsAny<CancellationToken>()))
+ .Callback(() =>
+ {
+ // Ensures that IHostedService instances are started in FILO order
+ Assert.Equal(index, startCallOrder++);
+ })
+ .Returns(async () =>
+ {
+ if (startConcurrently && hostedServiceCount > 1)
+ {
+ // Basically this will force all IHostedService instances to have StartAsync called before any one completes
+ startExecutionCount++;
+ int waitCount = 0;
+
+ while (startExecutionCount < hostedServiceCount && waitCount++ < 20)
+ {
+ await Task.Delay(10).ConfigureAwait(false);
+ }
+
+ // This will ensure that we truly are starting all services asynchronously
+ Assert.Equal(hostedServiceCount, startExecutionCount);
+ }
+ })
+ .Verifiable();
+
+ hostedServices[index] = service;
+ }
+
+ var builder = new HostBuilder();
+ using var host = Host.CreateDefaultBuilder().ConfigureHostConfiguration(configBuilder =>
+ {
+ configBuilder.AddInMemoryCollection(new KeyValuePair<string, string>[]
+ {
+ new KeyValuePair<string, string>("servicesStartConcurrently", startConcurrently.ToString()),
+ new KeyValuePair<string, string>("servicesStopConcurrently", stopConcurrently.ToString())
+ });
+ }).ConfigureServices(configurer =>
+ {
+ for (int i = 0; i < hostedServiceCount; i++)
+ {
+ var index = i;
+ configurer.Add(ServiceDescriptor.Singleton<IHostedService>(hostedServices[index].Object));
+ }
+ }).Build();
+
+ await host.StartAsync(CancellationToken.None);
+
+ await host.StopAsync(CancellationToken.None);
+
+ foreach (var service in hostedServices)
+ {
+ service.Verify();
+ }
+ }
+
  [Fact]
  public void CreateDefaultBuilder_IncludesContentRootByDefault()
  {