Add support for the ':' character in feature flags when using the default feature flag definition provider.

src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs

@@ -18,6 +18,7 @@ namespace Microsoft.FeatureManagement
     sealed class ConfigurationFeatureDefinitionProvider : IFeatureDefinitionProvider, IDisposable
     {
         private const string FeatureFiltersSectionName = "EnabledFor";
+        private static readonly string[] SectionSeparator = new string[] { ConfigurationPath.KeyDelimiter };
         private readonly IConfiguration _configuration;
         private readonly ConcurrentDictionary<string, FeatureDefinition> _definitions;
         private IDisposable _changeSubscription;
@@ -83,8 +84,39 @@ public async IAsyncEnumerable<FeatureDefinition> GetAllFeatureDefinitionsAsync()
 
         private FeatureDefinition ReadFeatureDefinition(string featureName)
         {
-            IConfigurationSection configuration = GetFeatureDefinitionSections()
-                                                    .FirstOrDefault(section => section.Key.Equals(featureName, StringComparison.OrdinalIgnoreCase));
+            IConfigurationSection configuration;
+
+            if (!featureName.Contains(ConfigurationPath.KeyDelimiter))
+            {
+                configuration = GetFeatureDefinitionSections()
+                    .FirstOrDefault(section => section.Key.Equals(featureName, StringComparison.OrdinalIgnoreCase));
+            }
+            else
+            {
+                //
+                // Feature names with configuration path delimiters require traversing children sections for resolution
+                IEnumerable<string> sectionNames = featureName.Split(SectionSeparator, StringSplitOptions.None);
+
+                IEnumerable<IConfigurationSection> sections;
+
+                IConfigurationSection section = null;
+
+                foreach (string sectionName in sectionNames)
+                {
+                    sections = section == null ?
+                        GetFeatureDefinitionSections() :
+                        section.GetChildren();
+
+                    section = sections.FirstOrDefault(section => section.Key.Equals(sectionName, StringComparison.OrdinalIgnoreCase));
+
+                    if (section == null)
+                    {
+                        break;
+                    }
+                }
+
+                configuration = section;
+            }
 
             if (configuration == null)
             {

tests/Tests.FeatureManagement/FeatureManagement.cs

@@ -26,6 +26,7 @@ public class FeatureManagement
         private const string OffFeature = "OffFeature";
         private const string ConditionalFeature = "ConditionalFeature";
         private const string ContextualFeature = "ContextualFeature";
+        private const string FeatureWithColons = "Feature:With:Colons";
 
         [Fact]
         public async Task ReadsConfiguration()
@@ -615,6 +616,46 @@ public async Task ThreadsafeSnapshot()
             }
         }
 
+        [Fact]
+        public async Task AllowsColon()
+        {
+            IConfiguration config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
+
+            var services = new ServiceCollection();
+
+            services
+                .AddSingleton(config)
+                .AddFeatureManagement()
+                .AddFeatureFilter<TestFilter>();
+
+            ServiceProvider serviceProvider = services.BuildServiceProvider();
+
+            IFeatureManager featureManager = serviceProvider.GetRequiredService<IFeatureManager>();
+
+            IEnumerable<IFeatureFilterMetadata> featureFilters = serviceProvider.GetRequiredService<IEnumerable<IFeatureFilterMetadata>>();
+
+            //
+            // Sync filter
+            TestFilter testFeatureFilter = (TestFilter)featureFilters.First(f => f is TestFilter);
+
+            bool called = false;
+
+            testFeatureFilter.Callback = (evaluationContext) =>
+            {
+                called = true;
+
+                Assert.Equal("V1", evaluationContext.Parameters["P1"]);
+
+                Assert.Equal(FeatureWithColons, evaluationContext.FeatureName);
+
+                return Task.FromResult(true);
+            };
+
+            await featureManager.IsEnabledAsync(FeatureWithColons);
+
+            Assert.True(called);
+        }
+
         private static void DisableEndpointRouting(MvcOptions options)
         {
 #if NET5_0 || NETCOREAPP3_1

tests/Tests.FeatureManagement/appsettings.json

@@ -63,6 +63,16 @@
           }
         }
       ]
+    },
+    "Feature:With:Colons": {
+      "EnabledFor": [
+        {
+          "Name": "Test",
+          "Parameters": {
+            "P1": "V1"
+          }
+        }
+      ]
     }
   }
 }