Allow access to child providers in ChainedConfigurationProvider

Fixes dotnet#44486

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

@@ -14,6 +14,7 @@ public static partial class ChainedBuilderExtensions
     public partial class ChainedConfigurationProvider : Microsoft.Extensions.Configuration.IConfigurationProvider, System.IDisposable
     {
         public ChainedConfigurationProvider(Microsoft.Extensions.Configuration.ChainedConfigurationSource source) { }
+        public Microsoft.Extensions.Configuration.IConfiguration Configuration { get { throw null; } }
         public void Dispose() { }
         public System.Collections.Generic.IEnumerable<string> GetChildKeys(System.Collections.Generic.IEnumerable<string> earlierKeys, string? parentPath) { throw null; }
         public Microsoft.Extensions.Primitives.IChangeToken GetReloadToken() { throw null; }

src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationProvider.cs

@@ -30,6 +30,11 @@ public ChainedConfigurationProvider(ChainedConfigurationSource source!!)
             _shouldDisposeConfig = source.ShouldDisposeConfiguration;
         }
 
+        /// <summary>
+        /// The chained configuration.
+        /// </summary>
+        public IConfiguration Configuration => _config;
+
         /// <summary>
         /// Tries to get a configuration value for the specified key.
         /// </summary>

src/libraries/Microsoft.Extensions.Configuration/tests/ChainedConfigurationProviderTests.cs

@@ -0,0 +1,83 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration.Memory;
+using Microsoft.Extensions.Primitives;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Extensions.Configuration.Test
+{
+    public class ChainedConfigurationProvierTests
+    {
+        [Fact]
+        public void Configuration_Basic()
+        {
+            var inputData = new Dictionary<string, string>() { { "a:b", "c" } };
+
+            ChainedConfigurationProvider chainedConfig;
+            chainedConfig = new ChainedConfigurationProvider(new ChainedConfigurationSource
+            {
+                Configuration = new ConfigurationBuilder()
+                    .Add(new MemoryConfigurationSource { InitialData = inputData })
+                    .Build(),
+                ShouldDisposeConfiguration = false,
+            });
+
+            Assert.True(chainedConfig.TryGet("a:b", out string? value));
+            Assert.Equal("c", value);
+            Assert.Equal("c", chainedConfig.Configuration["a:b"]);
+        }
+
+        [Fact]
+        public void ConfigurationRoot()
+        {
+            var inputData = new Dictionary<string, string>() { { "a:b", "c" } };
+            IConfigurationRoot configRoot = new ConfigurationBuilder()
+                    .Add(new MemoryConfigurationSource { InitialData = inputData })
+                    .Build();
+
+            var chainedConfigurationProvider = new ChainedConfigurationProvider(new ChainedConfigurationSource
+            {
+                Configuration = configRoot,
+                ShouldDisposeConfiguration = false,
+            });
+
+            Assert.NotNull(chainedConfigurationProvider.Configuration as IConfigurationRoot);
+            Assert.NotNull((chainedConfigurationProvider.Configuration as IConfigurationRoot).Providers);
+        }
+
+        [Fact]
+        public void ChainedConfigurationCouldExposeProvider()
+        {
+            var providers = new IConfigurationProvider[] {
+                new TestConfigurationProvider("foo", "foo-value")
+            };
+
+            var configRoot = new ConfigurationRoot(providers);
+
+            var chainedConfigurationSource = new ChainedConfigurationSource
+            {
+                Configuration = configRoot,
+                ShouldDisposeConfiguration = false,
+            };
+
+            var chainedConfigurationProvider = chainedConfigurationSource
+                .Build(new ConfigurationBuilder()) as ChainedConfigurationProvider;
+
+            Assert.NotNull(chainedConfigurationProvider.Configuration as IConfigurationRoot);
+            Assert.Equal(providers, (chainedConfigurationProvider.Configuration as IConfigurationRoot).Providers);
+        }
+
+        private class TestConfigurationProvider : ConfigurationProvider
+        {
+            public TestConfigurationProvider(string key, string value)
+                => Data.Add(key, value);
+        }
+    }
+}

src/libraries/Microsoft.Extensions.Configuration/tests/ConfigurationManagerTest.cs

@@ -221,7 +221,7 @@ public async Task ProviderDisposeDelayedWaitingOnConcurrentRead(Action<IConfigur
 
             builder.Add(new TestConfigurationSource(provider));
 
-            // Reading configuration will block on provider.TryRead() or profvider.GetChildKeys().
+            // Reading configuration will block on provider.TryRead() or provider.GetChildKeys().
             var readTask = Task.Run(() => concurrentReadAction(config));
             await provider.ReadStartedTask;