Added SimpleInjectorAddOptions.EnableHostedServiceResolution to disable hosted service resolution. Fixes #15

Author: dotnetjunkie

src/SimpleInjector.Integration.ServiceCollection/SimpleInjectorAddOptions.cs

@@ -5,6 +5,7 @@ namespace SimpleInjector.Integration.ServiceCollection
 {
     using System;
     using Microsoft.Extensions.DependencyInjection;
+    using Microsoft.Extensions.Hosting;
     using SimpleInjector.Advanced;
 
     /// <summary>
@@ -79,6 +80,15 @@ public IServiceProviderAccessor ServiceProviderAccessor
         /// <value>A boolean value.</value>
         public bool DisposeContainerWithServiceProvider { get; set; } = true;
 
+        /// <summary>
+        /// Gets or sets the value indicating whether the <see cref="Container"/> allows resolving
+        /// <see cref="IHostedService"/> implementations and injecting them with cross-wired framework dependencies.
+        /// The default is <c>true</c>. Set this value to <b>false</b> when running in an environment that does not
+        /// support hosted services, e.g. Azure Functions.
+        /// </summary>
+        /// /// <value>A boolean value.</value>
+        public bool EnableHostedServiceResolution { get; set; } = true;
+
         /// <summary>
         /// Gets the <see cref="IServiceProvider"/> instance that will be used by Simple Injector to resolve
         /// cross-wired framework components. It's value will be set when

src/SimpleInjector.Integration.ServiceCollection/SimpleInjectorServiceCollectionExtensions.cs

@@ -73,12 +73,18 @@ public static IServiceCollection AddSimpleInjector(
             // Set lifestyle before calling setupAction. Code in the delegate might depend on that.
             TrySetDefaultScopedLifestyle(container);
 
-            HookAspNetCoreHostHostedServiceServiceProviderInitialization(options);
-
             setupAction?.Invoke(options);
 
             RegisterServiceScope(options);
 
+            // Unfortunately, the addition of the IHostedService breaks Azure Functions. Azure Functions do no support
+            // IHostedService. See: https://stackoverflow.com/questions/59947132/. This is why we had to make this
+            // conditional.
+            if (options.EnableHostedServiceResolution)
+            {
+                HookAspNetCoreHostHostedServiceServiceProviderInitialization(options);
+            }
+
             if (options.AutoCrossWireFrameworkComponents)
             {
                 AddAutoCrossWiring(options);
@@ -597,16 +603,18 @@ private static void TrySetDefaultScopedLifestyle(Container container)
         private static void HookAspNetCoreHostHostedServiceServiceProviderInitialization(
             SimpleInjectorAddOptions options)
         {
-            // ASP.NET Core 3's new Host class resolves hosted services much earlier in the pipeline. This
-            // registration ensures that the IServiceProvider is assigned before such resolve takes place,
-            // to ensure that that hosted service can be injected with cross-wired dependencies.
-            options.Services.AddSingleton<IHostedService>(provider =>
+            // ASP.NET Core 3's new Host class resolves hosted services much earlier in the pipeline. This registration
+            // ensures that the IServiceProvider is assigned before such resolve takes place, to ensure that that
+            // hosted service can be injected with cross-wired dependencies.
+            // We must ensure that this hosted service gets resolved by ASP.NET before any other hosted service is
+            // resolve; that's why we do the Insert(0).
+            options.Services.Insert(0, ServiceDescriptor.Singleton<IHostedService>(provider =>
             {
                 options.SetServiceProviderIfNull(provider);
 
                 // We can't return null here, so we return an empty implementation.
                 return new NullSimpleInjectorHostedService();
-            });
+            }));
         }
 
         private static void EnsureMethodOnlyCalledOnce(