Expose IServiceProvider on inline initialization delegate

src/Serilog.AspNetCore/SerilogWebHostBuilderExtensions.cs

@@ -46,26 +46,26 @@ public static IWebHostBuilder UseSerilog(
         {
             if (builder == null) throw new ArgumentNullException(nameof(builder));
 
-            builder.ConfigureServices(collection =>
+            builder.ConfigureServices(services =>
             {
                 if (providers != null)
                 {
-                    collection.AddSingleton<ILoggerFactory>(services =>
+                    services.AddSingleton<ILoggerFactory>(serviceProvider =>
                     {
                         var factory = new SerilogLoggerFactory(logger, dispose, providers);
 
-                        foreach (var provider in services.GetServices<ILoggerProvider>())
+                        foreach (var provider in serviceProvider.GetServices<ILoggerProvider>())
                             factory.AddProvider(provider);
 
                         return factory;
                     });
                 }
                 else
                 {
-                    collection.AddSingleton<ILoggerFactory>(services => new SerilogLoggerFactory(logger, dispose));
+                    services.AddSingleton<ILoggerFactory>(serviceProvider => new SerilogLoggerFactory(logger, dispose));
                 }
 
-                ConfigureServices(collection, logger);
+                ConfigureServices(services, logger);
             });
 
             return builder;
@@ -92,7 +92,7 @@ public static IWebHostBuilder UseSerilog(
             if (builder == null) throw new ArgumentNullException(nameof(builder));
             if (configureLogger == null) throw new ArgumentNullException(nameof(configureLogger));
 
-            builder.ConfigureServices((context, collection) =>
+            builder.ConfigureServices((context, services) =>
             {
                 var loggerConfiguration = new LoggerConfiguration();
 
@@ -118,42 +118,92 @@ public static IWebHostBuilder UseSerilog(
                     Log.Logger = logger;
                 }
 
-                collection.AddSingleton<ILoggerFactory>(services =>
+                services.AddSingleton<ILoggerFactory>(serviceProvider =>
                 {
                     var factory = new SerilogLoggerFactory(registeredLogger, true, loggerProviders);
 
                     if (writeToProviders)
                     {
-                        foreach (var provider in services.GetServices<ILoggerProvider>())
+                        foreach (var provider in serviceProvider.GetServices<ILoggerProvider>())
                             factory.AddProvider(provider);
                     }
 
                     return factory;
                 });
 
-                ConfigureServices(collection, logger);
+                ConfigureServices(services, logger);
             });
             return builder;
         }
-
-        static void ConfigureServices(IServiceCollection collection, ILogger logger)
+
+        /// <summary>Sets Serilog as the logging provider.</summary>
+        /// <remarks>
+        /// A <see cref="WebHostBuilderContext"/> is supplied so that configuration and hosting information can be used.
+        /// The logger will be shut down when application services are disposed.
+        /// </remarks>
+        /// <param name="builder">The web host builder to configure.</param>
+        /// <param name="configureLogger">The delegate for configuring the <see cref="LoggerConfiguration" /> that will be used to construct a <see cref="Logger" />.</param>
+        /// <param name="writeToProviders">By default, Serilog does not write events to <see cref="ILoggerProvider"/>s registered through
+        /// the Microsoft.Extensions.Logging API. Normally, equivalent Serilog sinks are used in place of providers. Specify
+        /// <c>true</c> to write events to all providers.</param>
+        /// <returns>The web host builder.</returns>
+        public static IWebHostBuilder UseSerilog(
+            this IWebHostBuilder builder,
+            Action<WebHostBuilderContext, LoggerConfiguration, IServiceProvider> configureLogger,
+            bool writeToProviders = false)
+        {
+            if (builder == null) throw new ArgumentNullException(nameof(builder));
+            if (configureLogger == null) throw new ArgumentNullException(nameof(configureLogger));
+
+            builder.ConfigureServices((webHostBuilderContext, services) =>
+            {
+                services.AddSingleton<ILoggerFactory>(serviceProvider =>
+                {
+                    var loggerConfiguration = new LoggerConfiguration();
+
+                    LoggerProviderCollection loggerProviders = null;
+                    if (writeToProviders)
+                    {
+                        loggerProviders = new LoggerProviderCollection();
+                        loggerConfiguration.WriteTo.Providers(loggerProviders);
+                    }
+
+                    configureLogger(webHostBuilderContext, loggerConfiguration, serviceProvider);
+
+                    var loggerFactory = new SerilogLoggerFactory(
+                        loggerConfiguration.CreateLogger(),
+                        providerCollection: loggerProviders);
+
+                    if (writeToProviders)
+                    {
+                        foreach (var provider in serviceProvider.GetServices<ILoggerProvider>())
+                            loggerFactory.AddProvider(provider);
+                    }
+
+                    return loggerFactory;
+                });
+            });
+            return builder;
+        }
+
+        static void ConfigureServices(IServiceCollection services, ILogger logger)
         {
-            if (collection == null) throw new ArgumentNullException(nameof(collection));
+            if (services == null) throw new ArgumentNullException(nameof(services));
 
             if (logger != null)
             {
                 // This won't (and shouldn't) take ownership of the logger. 
-                collection.AddSingleton(logger);
+                services.AddSingleton(logger);
             }
 
             // Registered to provide two services...
             var diagnosticContext = new DiagnosticContext(logger);
 
             // Consumed by e.g. middleware
-            collection.AddSingleton(diagnosticContext);
+            services.AddSingleton(diagnosticContext);
 
             // Consumed by user code
-            collection.AddSingleton<IDiagnosticContext>(diagnosticContext);
+            services.AddSingleton<IDiagnosticContext>(diagnosticContext);
         }
     }
 }