Fixes configuration provider timing

Ensures `DotNetConsole.Configuration` properly reflects all configuration providers, including those added via `ConfigureAppConfiguration`, when accessed early in the application lifecycle. This is achieved by building the configuration root only once upon first access and rebuilding it when new configuration delegates are added.

Previously, `DotNetConsole.Configuration` was built too early, before custom `ConfigureAppConfiguration` delegates could be applied, leading to missing configuration sources. This change modifies the `DotNetConsoleBuilder` to create an `IConfigurationBuilder` initially and then builds the full `IConfigurationRoot` on-demand, incorporating all accumulated `ConfigureAppConfiguration` delegates.

Author: neoscie

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `ConfigureAppConfiguration` method to `DotNetConsoleBuilder` (re-)enabling custom configuration providers
 
+## Fixed
+
+- Fixed configuration provider timing: `DotNetConsole.Configuration` now properly reflects all configuration providers (including those added via `ConfigureAppConfiguration`) when accessed early in the application lifecycle. 
+
 ## [5.0.0] - 2025-01-27
 
 ### Added

Neolution.DotNet.Console/DotNetConsoleBuilder.cs

@@ -38,6 +38,21 @@ public class DotNetConsoleBuilder
         /// </summary>
         private readonly List<Action<HostBuilderContext, IConfigurationBuilder>> configurationDelegates = new();
 
+        /// <summary>
+        /// The initial configuration builder used to create dynamic configuration
+        /// </summary>
+        private readonly IConfigurationBuilder configurationBuilder;
+
+        /// <summary>
+        /// The host builder context used for dynamic configuration building
+        /// </summary>
+        private readonly HostBuilderContext hostBuilderContext;
+
+        /// <summary>
+        /// The built configuration root - built once when first accessed
+        /// </summary>
+        private IConfigurationRoot? builtConfiguration;
+
         /// <summary>
         /// Run only to check dependencies.
         /// </summary>
@@ -49,13 +64,20 @@ public class DotNetConsoleBuilder
         /// <param name="hostBuilder">The host builder.</param>
         /// <param name="commandLineParserResult">The command line parser result.</param>
         /// <param name="environment">The environment.</param>
-        /// <param name="configuration">The configuration.</param>
-        public DotNetConsoleBuilder(IHostBuilder hostBuilder, ParserResult<object> commandLineParserResult, IHostEnvironment environment, IConfiguration configuration)
+        /// <param name="configurationBuilder">The initial configuration builder.</param>
+        internal DotNetConsoleBuilder(IHostBuilder hostBuilder, ParserResult<object> commandLineParserResult, IHostEnvironment environment, IConfigurationBuilder configurationBuilder)
         {
+            ArgumentNullException.ThrowIfNull(configurationBuilder);
+
             this.hostBuilder = hostBuilder;
             this.commandLineParserResult = commandLineParserResult;
             this.Environment = environment;
-            this.Configuration = configuration;
+            this.configurationBuilder = configurationBuilder;
+            this.hostBuilderContext = new HostBuilderContext(new Dictionary<object, object>())
+            {
+                HostingEnvironment = environment,
+                Configuration = configurationBuilder.Build(),
+            };
         }
 
         /// <summary>
@@ -66,7 +88,35 @@ public DotNetConsoleBuilder(IHostBuilder hostBuilder, ParserResult<object> comma
         /// <summary>
         /// Gets a collection of configuration providers for the application to compose. This is useful for adding new configuration sources and providers.
         /// </summary>
-        public IConfiguration Configuration { get; }
+        public IConfiguration Configuration
+        {
+            get
+            {
+                // Build the configuration once when first accessed, similar to Microsoft's approach
+                if (this.builtConfiguration == null)
+                {
+                    // Create a new configuration builder based on the initial one
+                    var configBuilder = new ConfigurationBuilder();
+
+                    // Add all sources from the initial configuration builder
+                    foreach (var source in this.configurationBuilder.Sources)
+                    {
+                        configBuilder.Add(source);
+                    }
+
+                    // Apply all configuration delegates that have been added via ConfigureAppConfiguration
+                    foreach (var configureDelegate in this.configurationDelegates)
+                    {
+                        configureDelegate(this.hostBuilderContext, configBuilder);
+                    }
+
+                    // Build and store the configuration root
+                    this.builtConfiguration = configBuilder.Build();
+                }
+
+                return this.builtConfiguration;
+            }
+        }
 
         /// <summary>
         /// Gets the collection of services for the application to compose. This is useful for adding user provided or framework provided services.
@@ -83,6 +133,10 @@ public DotNetConsoleBuilder ConfigureAppConfiguration(Action<HostBuilderContext,
             ArgumentNullException.ThrowIfNull(configureDelegate);
 
             this.configurationDelegates.Add(configureDelegate);
+
+            // Reset the built configuration so it gets rebuilt on next access
+            this.builtConfiguration = null;
+
             return this;
         }
 
@@ -129,7 +183,7 @@ internal static DotNetConsoleBuilder CreateBuilderInternal(Assembly assembly, Ty
             // Create configuration and environment instances that are only valid before the host is built.
             // We want to expose these as read-only properties in the DotNetConsoleBuilder.
             var environment = DotNetConsoleDefaults.CreateConsoleEnvironment(args);
-            var configuration = DotNetConsoleDefaults.CreateConsoleConfiguration(assembly, args, environment);
+            var configBuilder = DotNetConsoleDefaults.CreateConsoleConfigurationBuilder(assembly, args, environment);
 
             // Create a HostBuilder
             var builder = Host.CreateDefaultBuilder(args)
@@ -153,7 +207,7 @@ internal static DotNetConsoleBuilder CreateBuilderInternal(Assembly assembly, Ty
                 .ToArray();
 
             var parsedArguments = Parser.Default.ParseArguments(args, verbTypes);
-            var consoleBuilder = new DotNetConsoleBuilder(builder, parsedArguments, environment, configuration);
+            var consoleBuilder = new DotNetConsoleBuilder(builder, parsedArguments, environment, configBuilder);
 
             // Apply any custom configuration delegates that will be added later via ConfigureAppConfiguration
             builder.ConfigureAppConfiguration((context, configBuilder) =>

Neolution.DotNet.Console/DotNetConsoleDefaults.cs

@@ -44,6 +44,18 @@ internal static DotNetConsoleEnvironment CreateConsoleEnvironment(string[] args)
         /// <param name="environment">The environment.</param>
         /// <returns>The <see cref="IConfiguration" />.</returns>
         internal static IConfiguration CreateConsoleConfiguration(Assembly assembly, string[] args, IHostEnvironment environment)
+        {
+            return CreateConsoleConfigurationBuilder(assembly, args, environment).Build();
+        }
+
+        /// <summary>
+        /// Creates the console configuration builder (without building it).
+        /// </summary>
+        /// <param name="assembly">The assembly.</param>
+        /// <param name="args">The arguments.</param>
+        /// <param name="environment">The environment.</param>
+        /// <returns>The <see cref="IConfigurationBuilder" />.</returns>
+        internal static IConfigurationBuilder CreateConsoleConfigurationBuilder(Assembly assembly, string[] args, IHostEnvironment environment)
         {
             var configurationBuilder = new ConfigurationBuilder()
                 .SetBasePath(environment.ContentRootPath)
@@ -62,7 +74,7 @@ internal static IConfiguration CreateConsoleConfiguration(Assembly assembly, str
 
             configurationBuilder.AddEnvironmentVariables();
 
-            return configurationBuilder.Build();
+            return configurationBuilder;
         }
 
         /// <summary>