Adds 'Settings' to Context and uses it as a cache of parameters

src/Microsoft.FeatureManagement/AssemblyInfo.cs

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System.Runtime.CompilerServices;
+
+// Tests
+[assembly: InternalsVisibleTo("Tests.FeatureManagement,PublicKey=" +
+"0024000004800000940000000602000000240000525341310004000001000100895524f60b44ff" +
+"3ae70fbea5662f61dd9d640de2205b7bd5359a43dda006e51d83d1f5f7a7d3f849267a0a28676d" +
+"cf49727a32487d4c75c4aacd5febb0069e1adc66ec63bbd18ec2276091a0e3c1326aa626c9e4db" +
+"800714a134f2a81e405f35752b55220021923429cb61776cd2fa66d25c335f8dc27bb92292905a" +
+"3798d896")]

src/Microsoft.FeatureManagement/ConfigurationFeatureDefinitionProvider.cs

@@ -15,8 +15,12 @@ namespace Microsoft.FeatureManagement
     /// <summary>
     /// A feature definition provider that pulls feature definitions from the .NET Core <see cref="IConfiguration"/> system.
     /// </summary>
-    sealed class ConfigurationFeatureDefinitionProvider : IFeatureDefinitionProvider, IDisposable
+    sealed class ConfigurationFeatureDefinitionProvider : IFeatureDefinitionProvider, IDisposable, IFeatureDefinitionProviderCacheable
     {
+        //
+        // IFeatureDefinitionProviderCacheable interface is only used to mark this provider as cacheable. This allows our test suite's
+        // provider to be marked for caching as well.
+
         private const string FeatureFiltersSectionName = "EnabledFor";
         private const string RequirementTypeKeyword = "RequirementType";
         private readonly IConfiguration _configuration;
@@ -179,7 +183,7 @@ We support
                         enabledFor.Add(new FeatureFilterConfiguration()
                         {
                             Name = section[nameof(FeatureFilterConfiguration.Name)],
-                            Parameters = section.GetSection(nameof(FeatureFilterConfiguration.Parameters))
+                            Parameters = new ConfigurationWrapper(section.GetSection(nameof(FeatureFilterConfiguration.Parameters)))
                         });
                     }
                 }

src/Microsoft.FeatureManagement/ConfigurationWrapper.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// Wraps an instance of IConfiguration. This allows the reference to be updated when the underlying IConfiguration is updated. 
+    /// This is useful for cache busting based on the reference.
+    /// </summary>
+    class ConfigurationWrapper : IConfiguration
+    {
+        private readonly IConfiguration _configuration;
+
+        public ConfigurationWrapper(IConfiguration configuration)
+        {
+            _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+        }
+
+        public string this[string key]
+        {
+            get => _configuration[key];
+            set => _configuration[key] = value;
+        }
+
+        public IEnumerable<IConfigurationSection> GetChildren() =>
+            _configuration.GetChildren();
+
+        public IChangeToken GetReloadToken() =>
+            _configuration.GetReloadToken();
+
+        public IConfigurationSection GetSection(string key) =>
+            _configuration.GetSection(key);
+    }
+}

src/Microsoft.FeatureManagement/FeatureFilterEvaluationContext.cs

@@ -19,5 +19,11 @@ public class FeatureFilterEvaluationContext
         /// The settings provided for the feature filter to use when evaluating whether the feature should be enabled.
         /// </summary>
         public IConfiguration Parameters { get; set; }
+
+        /// <summary>
+        /// A settings object, if any, that has been pre-bound from <see cref="Parameters"/>.
+        /// The settings are made available for <see cref="IFeatureFilter"/>s that implement <see cref="IFilterParametersBinder"/>.
+        /// </summary>
+        public object Settings { get; set; }
     }
 }

src/Microsoft.FeatureManagement/FeatureFilters/PercentageFilter.cs

@@ -12,7 +12,7 @@ namespace Microsoft.FeatureManagement.FeatureFilters
     /// A feature filter that can be used to activate a feature based on a random percentage.
     /// </summary>
     [FilterAlias(Alias)]
-    public class PercentageFilter : IFeatureFilter
+    public class PercentageFilter : IFeatureFilter, IFilterParametersBinder
     {
         private const string Alias = "Microsoft.Percentage";
         private readonly ILogger _logger;
@@ -26,14 +26,24 @@ public PercentageFilter(ILoggerFactory loggerFactory)
             _logger = loggerFactory.CreateLogger<PercentageFilter>();
         }
 
+        /// <summary>
+        /// Binds configuration representing filter parameters to <see cref="PercentageFilterSettings"/>.
+        /// </summary>
+        /// <param name="filterParameters">The configuration representing filter parameters that should be bound to <see cref="PercentageFilterSettings"/>.</param>
+        /// <returns><see cref="PercentageFilterSettings"/> that can later be used in feature evaluation.</returns>
+        public object BindParameters(IConfiguration filterParameters)
+        {
+            return filterParameters.Get<PercentageFilterSettings>() ?? new PercentageFilterSettings();
+        }
+
         /// <summary>
         /// Performs a percentage based evaluation to determine whether a feature is enabled.
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
         public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
-            PercentageFilterSettings settings = context.Parameters.Get<PercentageFilterSettings>() ?? new PercentageFilterSettings();
+            PercentageFilterSettings settings = (PercentageFilterSettings)context.Settings;
 
             bool result = true;
 

src/Microsoft.FeatureManagement/FeatureFilters/TimeWindowFilter.cs

@@ -12,7 +12,7 @@ namespace Microsoft.FeatureManagement.FeatureFilters
     /// A feature filter that can be used to activate a feature based on a time window.
     /// </summary>
     [FilterAlias(Alias)]
-    public class TimeWindowFilter : IFeatureFilter
+    public class TimeWindowFilter : IFeatureFilter, IFilterParametersBinder
     {
         private const string Alias = "Microsoft.TimeWindow";
         private readonly ILogger _logger;
@@ -26,14 +26,24 @@ public TimeWindowFilter(ILoggerFactory loggerFactory)
             _logger = loggerFactory.CreateLogger<TimeWindowFilter>();
         }
 
+        /// <summary>
+        /// Binds configuration representing filter parameters to <see cref="TimeWindowFilterSettings"/>.
+        /// </summary>
+        /// <param name="filterParameters">The configuration representing filter parameters that should be bound to <see cref="TimeWindowFilterSettings"/>.</param>
+        /// <returns><see cref="TimeWindowFilterSettings"/> that can later be used in feature evaluation.</returns>
+        public object BindParameters(IConfiguration filterParameters)
+        {
+            return filterParameters.Get<TimeWindowFilterSettings>() ?? new TimeWindowFilterSettings();
+        }
+
         /// <summary>
         /// Evaluates whether a feature is enabled based on a configurable time window.
         /// </summary>
         /// <param name="context">The feature evaluation context.</param>
         /// <returns>True if the feature is enabled, false otherwise.</returns>
         public Task<bool> EvaluateAsync(FeatureFilterEvaluationContext context)
         {
-            TimeWindowFilterSettings settings = context.Parameters.Get<TimeWindowFilterSettings>() ?? new TimeWindowFilterSettings();
+            TimeWindowFilterSettings settings = (TimeWindowFilterSettings)context.Settings;
 
             DateTimeOffset now = DateTimeOffset.UtcNow;
 

src/Microsoft.FeatureManagement/FeatureManager.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 //
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System;
@@ -14,15 +16,26 @@ namespace Microsoft.FeatureManagement
     /// <summary>
     /// Used to evaluate whether a feature is enabled or disabled.
     /// </summary>
-    class FeatureManager : IFeatureManager
+    class FeatureManager : IFeatureManager, IDisposable
     {
+        private readonly TimeSpan ParametersCacheSlidingExpiration = TimeSpan.FromMinutes(5);
+        private readonly TimeSpan ParametersCacheAbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1);
+
         private readonly IFeatureDefinitionProvider _featureDefinitionProvider;
         private readonly IEnumerable<IFeatureFilterMetadata> _featureFilters;
         private readonly IEnumerable<ISessionManager> _sessionManagers;
         private readonly ILogger _logger;
         private readonly ConcurrentDictionary<string, IFeatureFilterMetadata> _filterMetadataCache;
         private readonly ConcurrentDictionary<string, ContextualFeatureFilterEvaluator> _contextualFeatureFilterCache;
         private readonly FeatureManagementOptions _options;
+        private readonly IMemoryCache _parametersCache;
+
+        private class ConfigurationCacheItem
+        {
+            public IConfiguration Parameters { get; set; }
+
+            public object Settings { get; set; }
+        }
 
         public FeatureManager(
             IFeatureDefinitionProvider featureDefinitionProvider,
@@ -38,6 +51,7 @@ public FeatureManager(
             _filterMetadataCache = new ConcurrentDictionary<string, IFeatureFilterMetadata>();
             _contextualFeatureFilterCache = new ConcurrentDictionary<string, ContextualFeatureFilterEvaluator>();
             _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+            _parametersCache = new MemoryCache(new MemoryCacheOptions());
         }
 
         public Task<bool> IsEnabledAsync(string feature)
@@ -58,6 +72,11 @@ public async IAsyncEnumerable<string> GetFeatureNamesAsync()
             }
         }
 
+        public void Dispose()
+        {
+            _parametersCache.Dispose();
+        }
+
         private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appContext, bool useAppContext)
         {
             foreach (ISessionManager sessionManager in _sessionManagers)
@@ -99,10 +118,16 @@ private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appCo
                     // We iterate until we hit our target evaluation
                     bool targetEvaluation = !enabled;
 
+                    //
+                    // Keep track of the index of the filter we are evaluating
+                    int filterIndex = -1;
+
                     //
                     // For all enabling filters listed in the feature's state, evaluate them according to requirement type
                     foreach (FeatureFilterConfiguration featureFilterConfiguration in featureDefinition.EnabledFor)
                     {
+                        filterIndex++;
+
                         //
                         // Handle AlwaysOn filters
                         if (string.Equals(featureFilterConfiguration.Name, "AlwaysOn", StringComparison.OrdinalIgnoreCase))
@@ -144,7 +169,9 @@ private async Task<bool> IsEnabledAsync<TContext>(string feature, TContext appCo
                         {
                             ContextualFeatureFilterEvaluator contextualFilter = GetContextualFeatureFilter(featureFilterConfiguration.Name, typeof(TContext));
 
-                            if (contextualFilter != null && 
+                            BindSettings(filter, context, filterIndex);
+
+                            if (contextualFilter != null &&
                                 await contextualFilter.EvaluateAsync(context, appContext).ConfigureAwait(false) == targetEvaluation)
                             {
                                 enabled = targetEvaluation;
@@ -155,12 +182,15 @@ await contextualFilter.EvaluateAsync(context, appContext).ConfigureAwait(false)
 
                         //
                         // IFeatureFilter
-                        if (filter is IFeatureFilter featureFilter && 
-                            await featureFilter.EvaluateAsync(context).ConfigureAwait(false) == targetEvaluation)
+                        if (filter is IFeatureFilter featureFilter)
                         {
-                            enabled = targetEvaluation;
+                            BindSettings(filter, context, filterIndex);
+
+                            if (await featureFilter.EvaluateAsync(context).ConfigureAwait(false) == targetEvaluation) {
+                                enabled = targetEvaluation;
 
-                            break;
+                                break;
+                            }
                         }
                     }
                 }
@@ -187,6 +217,56 @@ await featureFilter.EvaluateAsync(context).ConfigureAwait(false) == targetEvalua
             return enabled;
         }
 
+        private void BindSettings(IFeatureFilterMetadata filter, FeatureFilterEvaluationContext context, int filterIndex)
+        {
+            IFilterParametersBinder binder = filter as IFilterParametersBinder;
+
+            if (binder == null)
+            {
+                return;
+            }
+
+            if (!(_featureDefinitionProvider is IFeatureDefinitionProviderCacheable))
+            {
+                context.Settings = binder.BindParameters(context.Parameters);
+
+                return;
+            }
+
+            object settings;
+
+            ConfigurationCacheItem cacheItem;
+
+            string cacheKey = $"{context.FeatureName}.{filterIndex}";
+
+            //
+            // Check if settings already bound from configuration or the parameters have changed
+            if (!_parametersCache.TryGetValue(cacheKey, out cacheItem) ||
+                cacheItem.Parameters != context.Parameters)
+            {
+                settings = binder.BindParameters(context.Parameters);
+
+                _parametersCache.Set(
+                    cacheKey,
+                    new ConfigurationCacheItem
+                    {
+                        Settings = settings,
+                        Parameters = context.Parameters
+                    },
+                    new MemoryCacheEntryOptions
+                    {
+                        SlidingExpiration = ParametersCacheSlidingExpiration,
+                        AbsoluteExpirationRelativeToNow = ParametersCacheAbsoluteExpirationRelativeToNow
+                    });
+            }
+            else
+            {
+                settings = cacheItem.Settings;
+            }
+
+            context.Settings = settings;
+        }
+
         private IFeatureFilterMetadata GetFeatureFilterMetadata(string filterName)
         {
             const string filterSuffix = "filter";

src/Microsoft.FeatureManagement/IFeatureDefinitionProviderCacheable.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// An interface that marks this provider's parameters are cacheable. This was implemented to allow the provider in our test suite to be cacheable.
+    /// </summary>
+    internal interface IFeatureDefinitionProviderCacheable
+    {
+    }
+}

src/Microsoft.FeatureManagement/IFilterParametersBinder.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+using Microsoft.Extensions.Configuration;
+
+namespace Microsoft.FeatureManagement
+{
+    /// <summary>
+    /// An interface used by the feature management system to pre-bind feature filter parameters to a settings type.
+    /// <see cref="IFeatureFilter"/>s can implement this interface to take advantage of caching of settings by the feature management system.
+    /// </summary>
+    public interface IFilterParametersBinder
+    {
+        /// <summary>
+        /// Binds a set of feature filter parameters to a settings object.
+        /// </summary>
+        /// <param name="parameters">The configuration representing filter parameters to bind to a settings object</param>
+        /// <returns>A settings object that is understood by the implementer of <see cref="IFilterParametersBinder"/>.</returns>
+        object BindParameters(IConfiguration parameters);
+    }
+}

src/Microsoft.FeatureManagement/Microsoft.FeatureManagement.csproj

@@ -36,6 +36,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="2.1.23" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="2.1.10" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="2.1.1" />
   </ItemGroup>