Process json key-values without reflection

src/Microsoft.Azure.AppConfiguration.AspNetCore/Microsoft.Azure.AppConfiguration.AspNetCore.csproj

@@ -34,7 +34,8 @@
 
   <PropertyGroup>
     <CodeAnalysisRuleSet>..\..\AzureAppConfigurationRules.ruleset</CodeAnalysisRuleSet>
-    <EnableNETAnalyzers>True</EnableNETAnalyzers>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
 </Project>

src/Microsoft.Azure.AppConfiguration.Functions.Worker/Microsoft.Azure.AppConfiguration.Functions.Worker.csproj

@@ -37,7 +37,8 @@
 
   <PropertyGroup>
     <CodeAnalysisRuleSet>..\..\AzureAppConfigurationRules.ruleset</CodeAnalysisRuleSet>
-    <EnableNETAnalyzers>True</EnableNETAnalyzers>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
 </Project>

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureKeyVaultReference/AzureKeyVaultKeyValueAdapter.cs

@@ -29,22 +29,12 @@ public AzureKeyVaultKeyValueAdapter(AzureKeyVaultSecretProvider secretProvider)
         /// returns the keyname and actual value
         public async Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(ConfigurationSetting setting, Logger logger, CancellationToken cancellationToken)
         {
-            KeyVaultSecretReference secretRef;
-
-            // Content validation
-            try
-            {
-                secretRef = JsonSerializer.Deserialize<KeyVaultSecretReference>(setting.Value);
-            }
-            catch (JsonException e)
-            {
-                throw CreateKeyVaultReferenceException("Invalid Key Vault reference.", setting, e, null);
-            }
+            string secretRefUri = ParseSecretReferenceUri(setting);
 
             // Uri validation
-            if (string.IsNullOrEmpty(secretRef.Uri) || !Uri.TryCreate(secretRef.Uri, UriKind.Absolute, out Uri secretUri) || !KeyVaultSecretIdentifier.TryCreate(secretUri, out KeyVaultSecretIdentifier secretIdentifier))
+            if (string.IsNullOrEmpty(secretRefUri) || !Uri.TryCreate(secretRefUri, UriKind.Absolute, out Uri secretUri) || !KeyVaultSecretIdentifier.TryCreate(secretUri, out KeyVaultSecretIdentifier secretIdentifier))
             {
-                throw CreateKeyVaultReferenceException("Invalid Key vault secret identifier.", setting, null, secretRef);
+                throw CreateKeyVaultReferenceException("Invalid Key vault secret identifier.", setting, null, secretRefUri);
             }
 
             string secret;
@@ -55,11 +45,11 @@ public async Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Con
             }
             catch (Exception e) when (e is UnauthorizedAccessException || (e.Source?.Equals(AzureIdentityAssemblyName, StringComparison.OrdinalIgnoreCase) ?? false))
             {
-                throw CreateKeyVaultReferenceException(e.Message, setting, e, secretRef);
+                throw CreateKeyVaultReferenceException(e.Message, setting, e, secretRefUri);
             }
             catch (Exception e) when (e is RequestFailedException || ((e as AggregateException)?.InnerExceptions?.All(e => e is RequestFailedException) ?? false))
             {
-                throw CreateKeyVaultReferenceException("Key vault error.", setting, e, secretRef);
+                throw CreateKeyVaultReferenceException("Key vault error.", setting, e, secretRefUri);
             }
 
             return new KeyValuePair<string, string>[]
@@ -68,15 +58,15 @@ public async Task<IEnumerable<KeyValuePair<string, string>>> ProcessKeyValue(Con
             };
         }
 
-        KeyVaultReferenceException CreateKeyVaultReferenceException(string message, ConfigurationSetting setting, Exception inner, KeyVaultSecretReference secretRef = null)
+        KeyVaultReferenceException CreateKeyVaultReferenceException(string message, ConfigurationSetting setting, Exception inner, string secretRefUri = null)
         {
             return new KeyVaultReferenceException(message, inner)
             {
                 Key = setting.Key,
                 Label = setting.Label,
                 Etag = setting.ETag.ToString(),
                 ErrorCode = (inner as RequestFailedException)?.ErrorCode,
-                SecretIdentifier = secretRef?.Uri
+                SecretIdentifier = secretRefUri
             };
         }
 
@@ -102,5 +92,50 @@ public bool NeedsRefresh()
         {
             return _secretProvider.ShouldRefreshKeyVaultSecrets();
         }
+
+        private string ParseSecretReferenceUri(ConfigurationSetting setting)
+        {
+            string secretRefUri = null;
+
+            try
+            {
+                var reader = new Utf8JsonReader(System.Text.Encoding.UTF8.GetBytes(setting.Value));
+
+                if (reader.Read() && reader.TokenType != JsonTokenType.StartObject)
+                {
+                    throw CreateKeyVaultReferenceException(ErrorMessages.InvalidKeyVaultReference, setting, null, null);
+                }
+
+                while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+                {
+                    if (reader.TokenType != JsonTokenType.PropertyName)
+                    {
+                        continue;
+                    }
+
+                    if (reader.GetString() == KeyVaultConstants.SecretReferenceUriJsonPropertyName)
+                    {
+                        if (reader.Read() && reader.TokenType == JsonTokenType.String)
+                        {
+                            secretRefUri = reader.GetString();
+                        }
+                        else
+                        {
+                            throw CreateKeyVaultReferenceException(ErrorMessages.InvalidKeyVaultReference, setting, null, null);
+                        }
+                    }
+                    else
+                    {
+                        reader.Skip();
+                    }
+                }
+            }
+            catch (JsonException e)
+            {
+                throw CreateKeyVaultReferenceException(ErrorMessages.InvalidKeyVaultReference, setting, e, null);
+            }
+
+            return secretRefUri;
+        }
     }
 }

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureKeyVaultReference/KeyVaultConstants.cs

@@ -6,5 +6,7 @@ namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.AzureKeyVault
     internal class KeyVaultConstants
     {
         public const string ContentType = "application/vnd.microsoft.appconfig.keyvaultref+json";
+
+        public const string SecretReferenceUriJsonPropertyName = "uri";
     }
 }

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/Constants/ErrorMessages.cs

@@ -7,5 +7,8 @@ internal class ErrorMessages
     {
         public const string CacheExpirationTimeTooShort = "The cache expiration time cannot be less than {0} milliseconds.";
         public const string SecretRefreshIntervalTooShort = "The secret refresh interval cannot be less than {0} milliseconds.";
+        public const string FeatureFlagInvalidJsonProperty = "Invalid property '{0}' for feature flag. Key: '{1}'. Found type: '{2}'. Expected type: '{3}'.";
+        public const string FeatureFlagInvalidFormat = "Invalid json format for feature flag. Key: '{0}'";
+        public const string InvalidKeyVaultReference = "Invalid Key Vault reference.";
     }
 }

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/Extensions/EventGridEventExtensions.cs

@@ -31,29 +31,59 @@ public static bool TryCreatePushNotification(this EventGridEvent eventGridEvent,
 
             if (Uri.TryCreate(eventGridEvent.Subject, UriKind.Absolute, out Uri resourceUri))
             {
-                JsonElement eventGridEventData;
+                string syncToken = null;
 
                 try
                 {
-                    eventGridEventData = JsonDocument.Parse(eventGridEvent.Data.ToString()).RootElement;
+                    var reader = new Utf8JsonReader(System.Text.Encoding.UTF8.GetBytes(eventGridEvent.Data.ToString()));
+
+                    if (reader.Read() && reader.TokenType != JsonTokenType.StartObject)
+                    {
+                        return false;
+                    }
+
+                    while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+                    {
+                        if (reader.TokenType != JsonTokenType.PropertyName)
+                        {
+                            continue;
+                        }
+
+                        if (reader.GetString() == SyncTokenPropertyName)
+                        {
+                            if (reader.Read() && reader.TokenType == JsonTokenType.String)
+                            {
+                                syncToken = reader.GetString();
+                            }
+                            else
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            reader.Skip();
+                        }
+                    }
                 }
                 catch (JsonException)
                 {
                     return false;
                 }
 
-                if (eventGridEventData.ValueKind == JsonValueKind.Object &&
-                    eventGridEventData.TryGetProperty(SyncTokenPropertyName, out JsonElement syncTokenJson) &&
-                    syncTokenJson.ValueKind == JsonValueKind.String)
+                if (syncToken == null)
                 {
-                    pushNotification = new PushNotification()
-                    {
-                        SyncToken = syncTokenJson.GetString(),
-                        EventType = eventGridEvent.EventType,
-                        ResourceUri = resourceUri
-                    };
-                    return true;
+                    return false;
                 }
+
+                pushNotification = new PushNotification()
+                {
+                    SyncToken = syncToken,
+                    EventType = eventGridEvent.EventType,
+                    ResourceUri = resourceUri
+                };
+
+                return true;
             }
 
             return false;

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/ClientFilter.cs

@@ -2,16 +2,13 @@
 // Licensed under the MIT license.
 //
 using System.Text.Json;
-using System.Text.Json.Serialization;
 
 namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
 {
     internal class ClientFilter
     {
-        [JsonPropertyName("name")]
         public string Name { get; set; }
 
-        [JsonPropertyName("parameters")]
         public JsonElement Parameters { get; set; }
     }
-}
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureConditions.cs

@@ -2,16 +2,13 @@
 // Licensed under the MIT license.
 //
 using System.Collections.Generic;
-using System.Text.Json.Serialization;
 
 namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
 {
     internal class FeatureConditions
     {
-        [JsonPropertyName("client_filters")]
         public List<ClientFilter> ClientFilters { get; set; } = new List<ClientFilter>();
 
-        [JsonPropertyName("requirement_type")]
         public string RequirementType { get; set; }
     }
-}
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureFlag.cs

@@ -1,19 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
-using System.Text.Json.Serialization;
 
 namespace Microsoft.Extensions.Configuration.AzureAppConfiguration.FeatureManagement
 {
     internal class FeatureFlag
     {
-        [JsonPropertyName("id")]
         public string Id { get; set; }
 
-        [JsonPropertyName("enabled")]
         public bool Enabled { get; set; }
 
-        [JsonPropertyName("conditions")]
         public FeatureConditions Conditions { get; set; }
     }
-}
+}

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/FeatureManagement/FeatureManagementConstants.cs

@@ -10,5 +10,13 @@ internal class FeatureManagementConstants
         public const string SectionName = "FeatureManagement";
         public const string EnabledFor = "EnabledFor";
         public const string RequirementType = "RequirementType";
+
+        public const string EnabledJsonPropertyName = "enabled";
+        public const string IdJsonPropertyName = "id";
+        public const string ConditionsJsonPropertyName = "conditions";
+        public const string RequirementTypeJsonPropertyName = "requirement_type";
+        public const string ClientFiltersJsonPropertyName = "client_filters";
+        public const string NameJsonPropertyName = "name";
+        public const string ParametersJsonPropertyName = "parameters";
     }
 }