Makes GetChildKeys more efficient

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

@@ -11,7 +11,7 @@ namespace Microsoft.Extensions.Configuration
     /// </summary>
     public class ConfigurationKeyComparer : IComparer<string>
     {
-        private static readonly string[] _keyDelimiterArray = new[] { ConfigurationPath.KeyDelimiter };
+        private const char KeyDelimiter = ':';
 
         /// <summary>
         /// The default instance.
@@ -29,49 +29,73 @@ public class ConfigurationKeyComparer : IComparer<string>
         /// <returns>Less than 0 if x is less than y, 0 if x is equal to y and greater than 0 if x is greater than y.</returns>
         public int Compare(string? x, string? y)
         {
-            string[] xParts = x?.Split(_keyDelimiterArray, StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
-            string[] yParts = y?.Split(_keyDelimiterArray, StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
+            ReadOnlySpan<char> xSpan = x.AsSpan();
+            ReadOnlySpan<char> ySpan = y.AsSpan();
+
+            xSpan = SkipAheadOnDelimiter(xSpan);
+            ySpan = SkipAheadOnDelimiter(ySpan);
 
             // Compare each part until we get two parts that are not equal
-            for (int i = 0; i < Math.Min(xParts.Length, yParts.Length); i++)
+            while (!xSpan.IsEmpty && !ySpan.IsEmpty)
             {
-                x = xParts[i];
-                y = yParts[i];
+                int xDelimiterIndex = xSpan.IndexOf(KeyDelimiter);
+                int yDelimiterIndex = ySpan.IndexOf(KeyDelimiter);
+
+                int compareResult = Compare(
+                    xDelimiterIndex == -1 ? xSpan : xSpan.Slice(0, xDelimiterIndex),
+                    yDelimiterIndex == -1 ? ySpan : ySpan.Slice(0, yDelimiterIndex));
+
+                if (compareResult != 0)
+                {
+                    return compareResult;
+                }
 
-                int value1 = 0;
-                int value2 = 0;
+                xSpan = xDelimiterIndex == -1 ? default :
+                    SkipAheadOnDelimiter(xSpan.Slice(xDelimiterIndex + 1));
+                ySpan = yDelimiterIndex == -1 ? default :
+                    SkipAheadOnDelimiter(ySpan.Slice(yDelimiterIndex + 1));
+            }
 
-                bool xIsInt = x != null && int.TryParse(x, out value1);
-                bool yIsInt = y != null && int.TryParse(y, out value2);
+            return xSpan.IsEmpty ? (ySpan.IsEmpty ? 0 : -1) : 1;
 
+            static ReadOnlySpan<char> SkipAheadOnDelimiter(ReadOnlySpan<char> a)
+            {
+                while (!a.IsEmpty && a[0] == KeyDelimiter)
+                {
+                    a = a.Slice(1);
+                }
+                return a;
+            }
+
+            static int Compare(ReadOnlySpan<char> a, ReadOnlySpan<char> b)
+            {
+#if NETCOREAPP
+                bool aIsInt = int.TryParse(a, out int value1);
+                bool bIsInt = int.TryParse(b, out int value2);
+#else
+                bool aIsInt = int.TryParse(a.ToString(), out int value1);
+                bool bIsInt = int.TryParse(b.ToString(), out int value2);
+#endif
                 int result;
 
-                if (!xIsInt && !yIsInt)
+                if (!aIsInt && !bIsInt)
                 {
                     // Both are strings
-                    result = string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
+                    result = a.CompareTo(b, StringComparison.OrdinalIgnoreCase);
                 }
-                else if (xIsInt && yIsInt)
+                else if (aIsInt && bIsInt)
                 {
                     // Both are int
                     result = value1 - value2;
                 }
                 else
                 {
                     // Only one of them is int
-                    result = xIsInt ? -1 : 1;
+                    result = aIsInt ? -1 : 1;
                 }
 
-                if (result != 0)
-                {
-                    // One of them is different
-                    return result;
-                }
+                return result;
             }
-
-            // If we get here, the common parts are equal.
-            // If they are of the same length, then they are totally identical
-            return xParts.Length - yParts.Length;
         }
     }
 }

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

@@ -14,6 +14,8 @@ public void CompareWithNull()
             ComparerTest(null, null, 0);
             ComparerTest(null, "a", -1);
             ComparerTest("b", null, 1);
+            ComparerTest(null, "a:b", -1);
+            ComparerTest(null, "a:b:c", -1);
         }
 
         [Fact]
@@ -32,6 +34,20 @@ public void CompareWithDifferentLengths()
             ComparerTest("aa", "a", 1);
         }
 
+        [Fact]
+        public void CompareWithEmpty()
+        {
+            ComparerTest(":", "", 0);
+            ComparerTest(":", "::", 0);
+            ComparerTest(null, "", 0);
+            ComparerTest(":", null, 0);
+            ComparerTest("::", null, 0);
+            ComparerTest(" : : ", null, 1);
+            ComparerTest("b: :a", "b::a", -1);
+            ComparerTest("b:\t:a", "b::a", -1);
+            ComparerTest("b::a: ", "b::a:", 1);
+        }
+
         [Fact]
         public void CompareWithLetters()
         {

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

@@ -59,6 +59,64 @@ public void LoadAndCombineKeyValuePairsFromDifferentConfigurationProviders()
             Assert.Null(config["NotExist"]);
         }
 
+        [Fact]
+        private void GetChildKeys_CanChainEmptyKeys()
+        {
+            var input = new Dictionary<string, string>() { };
+            for (int i = 0; i < 1000; i++)
+            {
+                input.Add(new string(' ', i), string.Empty);
+            }
+
+            IConfigurationRoot configurationRoot = new ConfigurationBuilder()
+                .Add(new MemoryConfigurationSource
+                {
+                    InitialData = input
+                })
+                .Build();
+
+            var chainedConfigurationSource = new ChainedConfigurationSource
+            {
+                Configuration = configurationRoot,
+                ShouldDisposeConfiguration = false,
+            };
+
+            var chainedConfiguration = new ChainedConfigurationProvider(chainedConfigurationSource);
+            IEnumerable<string> childKeys = chainedConfiguration.GetChildKeys(new string[0], null);
+            Assert.Equal(1000, childKeys.Count());
+            Assert.Equal(string.Empty, childKeys.First());
+            Assert.Equal(999, childKeys.Last().Length);
+        }
+
+        [Fact]
+        private void GetChildKeys_CanChainKeyWithNoDelimiter()
+        {
+            var input = new Dictionary<string, string>() { };
+            for (int i = 1000; i < 2000; i++)
+            {
+                input.Add(i.ToString(), string.Empty);
+            }
+
+            IConfigurationRoot configurationRoot = new ConfigurationBuilder()
+                .Add(new MemoryConfigurationSource
+                {
+                    InitialData = input
+                })
+                .Build();
+
+            var chainedConfigurationSource = new ChainedConfigurationSource
+            {
+                Configuration = configurationRoot,
+                ShouldDisposeConfiguration = false,
+            };
+
+            var chainedConfiguration = new ChainedConfigurationProvider(chainedConfigurationSource);
+            IEnumerable<string> childKeys = chainedConfiguration.GetChildKeys(new string[0], null);
+            Assert.Equal(1000, childKeys.Count());
+            Assert.Equal("1000", childKeys.First());
+            Assert.Equal("1999", childKeys.Last());
+        }
+
         [Fact]
         public void CanChainConfiguration()
         {