Configuration: Fix GetChildKeys to work correctly in prefixed configuration provider (#19)

Prior to this commit `GetChildKeys` was using a naive implementation that did not function correctly when there were multiple `IConfigurationProvider` implementations chained to the prefixed configuration.

This commit updates the method to ensure that it
 - returns the prefix and earlier keys if the parent path is null
 - returns just the earlier keys if the parent path is not null and does not have the prefix
 - correctly passes the parent path *without* the prefix to the child configuration providers when the parent path is prefixed

It also adds a test to validate that the fixes are sane.

Finally, in a fun episode of Yak Shaving, this tweaks `global.json` and `Directory.Build.props` to ensure that the project can build - there's an issue with upgrading the latest stable VS to 16.8 that inadvertently (and incorrectly) nukes SDK directories and our global.json was preventing the use of the 5.0 SDK for build purposes. And then Nerdbank got angry so needed an upgrade too. Yay!

Author: Dean Ward

global.json

@@ -1,7 +1,5 @@
 {
   "sdk": {
-    "version": "3.1.300",
-    "rollForward": "latestMinor",
     "allowPrerelease": false
   }
 }

src/Directory.Build.props

@@ -20,7 +20,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Nerdbank.GitVersioning" Version="3.0.28" PrivateAssets="all" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="all" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All"/>
   </ItemGroup>
 </Project>

src/StackExchange.Utils.Configuration/PrefixedConfigurationProvider.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.Extensions.Configuration;
@@ -8,49 +8,71 @@ namespace StackExchange.Utils
     internal class PrefixedConfigurationProvider : CompositeConfigurationProvider
     {
         private readonly string _prefixWithDelimiter;
+        private readonly string _prefix;
+
         public const char Delimiter = ':';
 
         public PrefixedConfigurationProvider(string prefix, IConfigurationRoot configurationRoot) : base(configurationRoot)
         {
+            _prefix = prefix;
             _prefixWithDelimiter = prefix + Delimiter;
         }
 
         public override IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string parentPath)
         {
-            var earlierKeyList = earlierKeys.ToList();
-            foreach (var provider in ConfigurationRoot.Providers)
+            if (parentPath != null && !parentPath.StartsWith(_prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                return earlierKeys;
+            }
+
+            var keys = new List<string>();
+            if (parentPath == null)
+            {
+                keys.Add(_prefix);
+            }
+            else
             {
-                foreach (var childKey in provider.GetChildKeys(earlierKeyList, parentPath))
+                string parentPathWithoutPrefix = null;
+                if (!parentPath.Equals(_prefix, StringComparison.OrdinalIgnoreCase))
                 {
-                    yield return _prefixWithDelimiter + childKey;
+                    parentPathWithoutPrefix = WithoutPrefix(parentPath);
+                }
+
+                foreach (var provider in ConfigurationRoot.Providers)
+                {
+                    foreach (var childKey in provider.GetChildKeys(keys, parentPathWithoutPrefix))
+                    {
+                        keys.Add(childKey);
+                    }
                 }
             }
+
+            return keys.Concat(earlierKeys).OrderBy(k => k, ConfigurationKeyComparer.Instance);
         }
 
         public override void Set(string key, string value)
         {
-            if (!key.StartsWith(_prefixWithDelimiter) || key.Length == _prefixWithDelimiter.Length)
+            if (!key.StartsWith(_prefixWithDelimiter, StringComparison.OrdinalIgnoreCase) || key.Length == _prefixWithDelimiter.Length)
             {
                 return;
             }
 
-            // TODO: make this moar efficient!
-            // slice off the prefix so we can fetch from our underlying providers
-            base.Set(key.AsSpan().Slice(_prefixWithDelimiter.Length).ToString(), value);
+            base.Set(WithoutPrefix(key), value);
         }
 
         public override bool TryGet(string key, out string value)
         {
-            if (!key.StartsWith(_prefixWithDelimiter) || key.Length == _prefixWithDelimiter.Length)
+            if (!key.StartsWith(_prefixWithDelimiter, StringComparison.OrdinalIgnoreCase) || key.Length == _prefixWithDelimiter.Length)
             {
                 value = null;
                 return false;
             }
 
-            // TODO: make this moar efficient!
-            // slice off the prefix so we can fetch from our underlying providers
-            var keyWithoutPrefix = key.AsSpan().Slice(_prefixWithDelimiter.Length);
-            return base.TryGet(keyWithoutPrefix.ToString(), out value);
+            return base.TryGet(WithoutPrefix(key), out value);
         }
+
+        // TODO: make this moar efficient!
+        // slice off the prefix so we can fetch from our underlying providers
+        private string WithoutPrefix(string path) => path == null ? path : path.AsSpan().Slice(_prefixWithDelimiter.Length).ToString();
     }
 }

tests/StackExchange.Utils.Tests/PrefixedConfigurationProviderTests.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.Configuration;
 using Xunit;
@@ -23,6 +23,37 @@ public void InvalidArguments()
             );
         }
 
+        [Fact]
+        public void PrefixesDoNotTrashPreviousKeys()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(
+                new Dictionary<string, string>
+                {
+                    ["Kestrel:Endpoints:Http:Url"] = "http://*:6001/",
+                    ["Testing:Blah"] = "BaseValue"
+                }
+                )
+                .WithPrefix(
+                    "secrets",
+                    c =>
+                    {
+                        c.AddInMemoryCollection(
+                            new Dictionary<string, string>
+                            {
+                                ["Testing:Blah"] = "ShouldNotOverride",
+                                ["ShouldBeAccessibleUsingPrefix"] = "Test"
+                            });
+                    })
+                .Build();
+
+            Assert.Equal("http://*:6001/", configuration.GetValue<string>("Kestrel:Endpoints:Http:Url"));
+            Assert.Equal("BaseValue", configuration.GetValue<string>("Testing:Blah"));
+            Assert.Equal("ShouldNotOverride", configuration.GetValue<string>("secrets:Testing:Blah"));
+            Assert.Equal("Test", configuration.GetValue<string>("secrets:ShouldBeAccessibleUsingPrefix"));
+            Assert.Null(configuration.GetValue<string>("ShouldBeAccessibleUsingPrefix"));
+        }
+
         [Fact]
         public void ValuesArePrefixed()
         {