Split validation and key mapping into two methods.

Author: StephenMolloy

src/Azure/AzureKeyVaultConfigBuilder.cs

@@ -143,14 +143,33 @@ public override ICollection<KeyValuePair<string, string>> GetAllValues(string pr
             return d;
         }
 
+        /// <summary>
+        /// Transform the given key to an intermediate format that will be used to look up values in backing store.
+        /// </summary>
+        /// <param name="key">The string to be mapped.</param>
+        /// <returns>The key string to be used while looking up config values..</returns>
+        public override string MapKey(string key)
+        {
+            if (String.IsNullOrEmpty(key))
+                return key;
+
+            // Colons and underscores are common in appSettings keys, but not allowed in key vault key names.
+            // It's likely that apps will want to lookup config values with these characters in their name in
+            // key vault. More extensive key mapping can be done with subclasses. But let's handle the most
+            // most common case here.
+            key = key.Replace(':', '-');
+            key = key.Replace('_', '-');
+            return key;
+        }
+
         /// <summary>
         /// Makes a determination about whether the input key is valid for this builder and backing store.
         /// </summary>
         /// <param name="key">The string to be validated. May be partial.</param>
         /// <returns>True if the string is valid. False if the string is not a valid key.</returns>
-        public override bool ValidateKey(ref string key)
+        public override bool ValidateKey(string key)
         {
-            // Key Vault only allows alphanumerics and '-'. This builder also allows for one '/'.
+            // Key Vault only allows alphanumerics and '-'. This builder also allows for one '/' for versioning.
             return Regex.IsMatch(key, "^[a-zA-Z0-9-]+(/?[a-zA-Z0-9-]+)?$");
         }
 

src/AzureAppConfig/AzureAppConfigurationBuilder.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Azure.AppConfiguration.Azconfig;
@@ -100,10 +101,23 @@ protected override void LazyInitialize(string name, NameValueCollection config)
         /// </summary>
         /// <param name="key">The string to be validated. May be partial.</param>
         /// <returns>True if the string is valid. False if the string is not a valid key.</returns>
-        public override bool ValidateKey(ref string key)
+        public override bool ValidateKey(string key)
         {
-            // Azure App Config does not restrict key names, although a couple characters have special meaning if not escaped.
-            // We may want to restrict using those characters unescaped in a key name in the future.
+            // From - https://docs.microsoft.com/en-us/azure/azure-app-configuration/concept-key-value
+            // You can use any unicode character in key names entered into App Configuration except for *, ,, and \. These characters are
+            // reserved.If you need to include a reserved character, you must escape it by using \{ Reserved Character}.
+            if (String.IsNullOrWhiteSpace(key))
+                return false;
+
+            if (key.Contains('*') || key.Contains(','))
+                return false;
+
+            // We don't want to completely disallow '\' since it is used for escaping. But writing a full parser for someone elses
+            // naming format could be error prone. If we see a '\' followed by a '{', just call it good. Don't bother with the Regex
+            // if there aren't any backslashes though.
+            if (key.Contains('\\'))
+                return !Regex.IsMatch(key, @"\\[^{]");
+
             return true;
         }
 

src/Base/KeyValueConfigBuilder.cs

@@ -68,12 +68,18 @@ public abstract class KeyValueConfigBuilder : ConfigurationBuilder
         /// <returns>A collection of key/value pairs.</returns>
         public abstract ICollection<KeyValuePair<string, string>> GetAllValues(string prefix);
 
+        /// <summary>
+        /// Transform the given key to an intermediate format that will be used to look up values in backing store.
+        /// </summary>
+        /// <param name="key">The string to be mapped.</param>
+        /// <returns>The key string to be used while looking up config values..</returns>
+        public virtual string MapKey(string key) { return key; }
         /// <summary>
         /// Makes a determination about whether the input key is valid for this builder and backing store.
         /// </summary>
         /// <param name="key">The string to be validated. May be partial.</param>
         /// <returns>True if the string is valid. False if the string is not a valid key.</returns>
-        public virtual bool ValidateKey(ref string key) { return true; }
+        public virtual bool ValidateKey(string key) { return true; }
         /// <summary>
         /// Transforms the raw key to a new string just before updating items in Strict and Greedy modes.
         /// </summary>
@@ -246,10 +252,10 @@ private void EnsureGreedyInitialized()
                 // can't 'cache' them as we go along. Slurp them all up now. But only once. ;)
                 if (!_greedyInitialized)
                 {
-                    string prefix = KeyPrefix;  // Do this outside the lock. It ensures _cachedValues is initialized.
+                    string prefix = MapKey(KeyPrefix);  // Do this outside the lock. It ensures _cachedValues is initialized.
                     lock (_cachedValues)
                     {
-                        if (!_greedyInitialized && (String.IsNullOrEmpty(prefix) || ValidateKey(ref prefix)))
+                        if (!_greedyInitialized && (String.IsNullOrEmpty(prefix) || ValidateKey(prefix)))
                         {
                             foreach (KeyValuePair<string, string> kvp in GetAllValues(prefix))
                             {
@@ -301,9 +307,9 @@ private string GetValueInternal(string key)
 
                 // Stripping Prefix in strict mode means from the source key. The static config file will have a prefix-less key to match.
                 // ie <add key="MySetting" /> should only match the key/value (KeyPrefix + "MySetting") from the source.
-                string sourceKey = (StripPrefix) ? KeyPrefix + key : key;
+                string sourceKey = MapKey((StripPrefix) ? KeyPrefix + key : key);
 
-                if (!ValidateKey(ref sourceKey))
+                if (!ValidateKey(sourceKey))
                     return null;
 
                 return (_cachedValues.ContainsKey(sourceKey)) ? _cachedValues[sourceKey] : _cachedValues[sourceKey] = GetValue(sourceKey);

test/Microsoft.Configuration.ConfigurationBuilders.Test/BaseTests.cs

@@ -786,10 +786,9 @@ public void SetTokenPattern(string newPattern)
 
     class FakeKeyMappingConfigBuilder : FakeConfigBuilder
     {
-        public override bool ValidateKey(ref string key)
+        public override string MapKey(string key)
         {
-            key = key.Replace(":", "_");
-            return true;
+            return key.Replace(":", "_");
         }
 
         public override string UpdateKey(string rawKey)