Observe more mutations to configuration and services (#34615)

* Observe more mutations to configuration and services
- When using WebApplicationFactory with the WebApplicationFactory, mutations are made very late that aren't observable via the WebApplicationBuilder.Configuration nor  WebApplicationBuilder.Services. The configuration tries to be the source of truth but more sources are added it can't see, the same with the service collection (though that is more rare). To fix this, the strategy is to use the initial service collection and configuration as data that will feed into the final IConfigurationBuilder and IServiceCollection, and then "update" these properties to point back to the final configuration and service collection. Results in the properties on the builder being consistent (from a data POV) with the built application.
- Added tests that mimic what the WebApplicationFactory does but using the diagnostic source to capture the right events for the right host and mutate the IHostBuilder.

Author: davidfowl

src/DefaultBuilder/src/WebApplicationBuilder.cs

@@ -23,10 +23,12 @@ public sealed class WebApplicationBuilder
         private readonly ConfigureHostBuilder _deferredHostBuilder;
         private readonly ConfigureWebHostBuilder _deferredWebHostBuilder;
         private readonly WebHostEnvironment _environment;
+        private readonly WebApplicationServiceCollection _services = new();
         private WebApplication? _builtApplication;
 
         internal WebApplicationBuilder(Assembly? callingAssembly, string[]? args = null)
         {
+            Services = _services;
             // HACK: MVC and Identity do this horrible thing to get the hosting environment as an instance
             // from the service collection before it is built. That needs to be fixed...
             Environment = _environment = new WebHostEnvironment(callingAssembly);
@@ -46,9 +48,6 @@ internal WebApplicationBuilder(Assembly? callingAssembly, string[]? args = null)
             WebHost = _deferredWebHostBuilder = new ConfigureWebHostBuilder(Configuration, _environment, Services);
             Host = _deferredHostBuilder = new ConfigureHostBuilder(Configuration, _environment, Services);
 
-            // Register Configuration as IConfiguration so updates can be observed even after the WebApplication is built.
-            Services.AddSingleton<IConfiguration>(Configuration);
-
             // Add default services
             _deferredHostBuilder.ConfigureDefaults(args);
 
@@ -73,7 +72,7 @@ internal WebApplicationBuilder(Assembly? callingAssembly, string[]? args = null)
         /// <summary>
         /// A collection of services for the application to compose. This is useful for adding user provided or framework provided services.
         /// </summary>
-        public IServiceCollection Services { get; } = new ServiceCollection();
+        public IServiceCollection Services { get; }
 
         /// <summary>
         /// A collection of configuration providers for the application to compose. This is useful for adding new configuration sources and providers.
@@ -103,11 +102,33 @@ internal WebApplicationBuilder(Assembly? callingAssembly, string[]? args = null)
         /// <returns>A configured <see cref="WebApplication"/>.</returns>
         public WebApplication Build()
         {
+            // Copy the configuration sources into the final IConfigurationBuilder
+            _hostBuilder.ConfigureHostConfiguration(builder =>
+            {
+                foreach (var source in ((IConfigurationBuilder)Configuration).Sources)
+                {
+                    builder.Sources.Add(source);
+                }
+
+                foreach (var (key, value) in ((IConfigurationBuilder)Configuration).Properties)
+                {
+                    builder.Properties[key] = value;
+                }
+            });
+
             // We call ConfigureWebHostDefaults AGAIN because config might be added like "ForwardedHeaders_Enabled"
             // which can add even more services. If not for that, we probably call _hostBuilder.ConfigureWebHost(ConfigureWebHost)
             // instead in order to avoid duplicate service registration.
             _hostBuilder.ConfigureWebHostDefaults(ConfigureWebHost);
-            return _builtApplication = new WebApplication(_hostBuilder.Build());
+
+            _builtApplication = new WebApplication(_hostBuilder.Build());
+
+            // Make builder.Configuration match the final configuration. To do that
+            // we clear the sources and add the built configuration as a source
+            ((IConfigurationBuilder)Configuration).Sources.Clear();
+            Configuration.AddConfiguration(_builtApplication.Configuration);
+
+            return _builtApplication;
         }
 
         private void ConfigureApplication(WebHostBuilderContext context, IApplicationBuilder app)
@@ -183,20 +204,10 @@ private void ConfigureApplication(WebHostBuilderContext context, IApplicationBui
 
         private void ConfigureWebHost(IWebHostBuilder genericWebHostBuilder)
         {
-            _hostBuilder.ConfigureHostConfiguration(builder =>
-            {
-                // All the sources in builder.Sources should be in Configuration.Sources
-                // already thanks to the BootstrapHostBuilder.
-                builder.Sources.Clear();
-
-                foreach (var (key, value) in ((IConfigurationBuilder)Configuration).Properties)
-                {
-                    builder.Properties[key] = value;
-                }
-
-                builder.AddConfiguration(Configuration, shouldDisposeConfiguration: true);
-            });
+            genericWebHostBuilder.Configure(ConfigureApplication);
 
+            // This needs to go here to avoid adding the IHostedService that boots the server twice (the GenericWebHostService).
+            // Copy the services that were added via WebApplicationBuilder.Services into the final IServiceCollection
             genericWebHostBuilder.ConfigureServices((context, services) =>
             {
                 // We've only added services configured by the GenericWebHostBuilder and WebHost.ConfigureWebDefaults
@@ -209,24 +220,21 @@ private void ConfigureWebHost(IWebHostBuilder genericWebHostBuilder)
                 // but we want to add services in the WebApplicationBuilder constructor so code can inspect
                 // WebApplicationBuilder.Services. At the same time, we want to be able which services are loaded
                 // to react to config changes (e.g. ForwardedHeadersStartupFilter).
-                foreach (var s in Services)
+                foreach (var s in _services)
                 {
                     services.Add(s);
                 }
 
                 // Add any services to the user visible service collection so that they are observable
                 // just in case users capture the Services property. Orchard does this to get a "blueprint"
-                // of the service collection. The order needs to be preserved here so we clear the original
-                // collection and add all of the services in order.
-                Services.Clear();
-                foreach (var s in services)
-                {
-                    Services.Add(s);
-                }
-            });
+                // of the service collection
 
-            genericWebHostBuilder.Configure(ConfigureApplication);
+                // Drop the reference to the existing collection and set the inner collection
+                // to the new one. This allows code that has references to the service collection to still function.
+                _services.InnerCollection = services;
+            });
 
+            // Run the other callbacks on the final host builder
             _deferredHostBuilder.RunDeferredCallbacks(_hostBuilder);
 
             _environment.ApplyEnvironmentSettings(genericWebHostBuilder);

src/DefaultBuilder/src/WebApplicationServiceCollection.cs

@@ -0,0 +1,76 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.AspNetCore
+{
+    internal sealed class WebApplicationServiceCollection : IServiceCollection
+    {
+        private IServiceCollection _services = new ServiceCollection();
+
+        public ServiceDescriptor this[int index] { get => _services[index]; set => _services[index] = value; }
+
+        public int Count => _services.Count;
+
+        public bool IsReadOnly => _services.IsReadOnly;
+
+        public IServiceCollection InnerCollection { get => _services; set => _services = value; }
+
+        public void Add(ServiceDescriptor item)
+        {
+            _services.Add(item);
+        }
+
+        public void Clear()
+        {
+            _services.Clear();
+        }
+
+        public bool Contains(ServiceDescriptor item)
+        {
+            return _services.Contains(item);
+        }
+
+        public void CopyTo(ServiceDescriptor[] array, int arrayIndex)
+        {
+            _services.CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerator<ServiceDescriptor> GetEnumerator()
+        {
+            return _services.GetEnumerator();
+        }
+
+        public int IndexOf(ServiceDescriptor item)
+        {
+            return _services.IndexOf(item);
+        }
+
+        public void Insert(int index, ServiceDescriptor item)
+        {
+            _services.Insert(index, item);
+        }
+
+        public bool Remove(ServiceDescriptor item)
+        {
+            return _services.Remove(item);
+        }
+
+        public void RemoveAt(int index)
+        {
+            _services.RemoveAt(index);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

src/DefaultBuilder/test/Microsoft.AspNetCore.Tests/WebApplicationTests.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.Tracing;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.HostFiltering;
@@ -210,6 +212,64 @@ public void WebApplicationBuilderWebHostUseSettingCanBeReadByConfiguration()
             Assert.Equal("another", builder.Configuration["B"]);
         }
 
+        [Fact]
+        public async Task WebApplicationCanObserveConfigurationChangesMadeInBuild()
+        {
+            // This mimics what WebApplicationFactory<T> does and runs configure
+            // services callbacks
+            using var listener = new HostingListener(hostBuilder =>
+            {
+                hostBuilder.ConfigureHostConfiguration(config =>
+                {
+                    config.AddInMemoryCollection(new Dictionary<string, string>()
+                    {
+                        { "A", "A" },
+                        { "B", "B" },
+                    });
+                });
+
+                hostBuilder.ConfigureAppConfiguration(config =>
+                {
+                    config.AddInMemoryCollection(new Dictionary<string, string>()
+                    {
+                        { "C", "C" },
+                        { "D", "D" },
+                    });
+                });
+
+                hostBuilder.ConfigureWebHost(builder =>
+                {
+                    builder.UseSetting("E", "E");
+
+                    builder.ConfigureAppConfiguration(config =>
+                    {
+                        config.AddInMemoryCollection(new Dictionary<string, string>()
+                        {
+                            { "F", "F" },
+                        });
+                    });
+                });
+            });
+
+            var builder = WebApplication.CreateBuilder();
+
+            await using var app = builder.Build();
+
+            Assert.Equal("A", app.Configuration["A"]);
+            Assert.Equal("B", app.Configuration["B"]);
+            Assert.Equal("C", app.Configuration["C"]);
+            Assert.Equal("D", app.Configuration["D"]);
+            Assert.Equal("E", app.Configuration["E"]);
+            Assert.Equal("F", app.Configuration["F"]);
+
+            Assert.Equal("A", builder.Configuration["A"]);
+            Assert.Equal("B", builder.Configuration["B"]);
+            Assert.Equal("C", builder.Configuration["C"]);
+            Assert.Equal("D", builder.Configuration["D"]);
+            Assert.Equal("E", builder.Configuration["E"]);
+            Assert.Equal("F", builder.Configuration["F"]);
+        }
+
         [Fact]
         public void WebApplicationBuilderHostProperties_IsCaseSensitive()
         {
@@ -300,6 +360,34 @@ public void WebApplication_CanResolveDefaultServicesFromServiceCollection()
             Assert.Equal(env0.ContentRootPath, env1.ContentRootPath);
         }
 
+        [Fact]
+        public async Task WebApplication_CanResolveServicesAddedAfterBuildFromServiceCollection()
+        {
+            // This mimics what WebApplicationFactory<T> does and runs configure
+            // services callbacks
+            using var listener = new HostingListener(hostBuilder =>
+            {
+                hostBuilder.ConfigureServices(services =>
+                {
+                    services.AddSingleton<IService, Service>();
+                });
+            });
+
+            var builder = WebApplication.CreateBuilder();
+
+            // Add the service collection to the service collection
+            builder.Services.AddSingleton(builder.Services);
+
+            await using var app = builder.Build();
+
+            var service0 = app.Services.GetRequiredService<IService>();
+
+            var service1 = app.Services.GetRequiredService<IServiceCollection>().BuildServiceProvider().GetRequiredService<IService>();
+
+            Assert.IsType<Service>(service0);
+            Assert.IsType<Service>(service1);
+        }
+
         [Fact]
         public void WebApplication_CanResolveDefaultServicesFromServiceCollectionInCorrectOrder()
         {
@@ -445,6 +533,68 @@ public async Task WebApplicationBuilder_StartupFilterCanAddTerminalMiddleware()
             Assert.Equal(418, (int)terminalResult.StatusCode);
         }
 
+        private class Service : IService { }
+        private interface IService { }
+
+        private sealed class HostingListener : IObserver<DiagnosticListener>, IObserver<KeyValuePair<string, object>>, IDisposable
+        {
+            private readonly Action<IHostBuilder> _configure;
+            private static readonly AsyncLocal<HostingListener> _currentListener = new();
+            private readonly IDisposable _subscription0;
+            private IDisposable _subscription1;
+
+            public HostingListener(Action<IHostBuilder> configure)
+            {
+                _configure = configure;
+
+                _subscription0 = DiagnosticListener.AllListeners.Subscribe(this);
+
+                _currentListener.Value = this;
+            }
+
+            public void OnCompleted()
+            {
+
+            }
+
+            public void OnError(Exception error)
+            {
+
+            }
+
+            public void OnNext(DiagnosticListener value)
+            {
+                if (_currentListener.Value != this)
+                {
+                    // Ignore events that aren't for this listener
+                    return;
+                }
+
+                if (value.Name == "Microsoft.Extensions.Hosting")
+                {
+                    _subscription1 = value.Subscribe(this);
+                }
+            }
+
+            public void OnNext(KeyValuePair<string, object> value)
+            {
+                if (value.Key == "HostBuilding")
+                {
+                    _configure?.Invoke((IHostBuilder)value.Value);
+                }
+            }
+
+            public void Dispose()
+            {
+                // Undo this here just in case the code unwinds synchronously since that doesn't revert
+                // the execution context to the original state. Only async methods do that on exit.
+                _currentListener.Value = null;
+
+                _subscription0.Dispose();
+                _subscription1?.Dispose();
+            }
+        }
+
         private class CustomHostLifetime : IHostLifetime
         {
             public Task StopAsync(CancellationToken cancellationToken)