diff --git a/examples/VariantServiceDemo/Program.cs b/examples/VariantServiceDemo/Program.cs index a866d02d..de43ffb9 100644 --- a/examples/VariantServiceDemo/Program.cs +++ b/examples/VariantServiceDemo/Program.cs @@ -19,10 +19,11 @@ builder.Services.AddApplicationInsightsTelemetry(); // -// Add variant implementations of ICalculator -builder.Services.AddSingleton(); +// Add variant implementations of ICalculator using keyed services so that only the +// implementation matching the assigned variant is instantiated on demand. +builder.Services.AddKeyedSingleton("DefaultCalculator"); -builder.Services.AddSingleton(); +builder.Services.AddKeyedSingleton("RemoteCalculator"); // // Enter feature management diff --git a/src/Microsoft.FeatureManagement/FeatureManagementBuilderExtensions.cs b/src/Microsoft.FeatureManagement/FeatureManagementBuilderExtensions.cs index f8635a79..53dd19cf 100644 --- a/src/Microsoft.FeatureManagement/FeatureManagementBuilderExtensions.cs +++ b/src/Microsoft.FeatureManagement/FeatureManagementBuilderExtensions.cs @@ -63,14 +63,14 @@ public static IFeatureManagementBuilder WithVariantService(this IFeatu builder.Services.AddScoped>(sp => new VariantServiceProvider( featureName, sp.GetRequiredService(), - sp.GetRequiredService>())); + sp)); } else { builder.Services.AddSingleton>(sp => new VariantServiceProvider( featureName, sp.GetRequiredService(), - sp.GetRequiredService>())); + sp)); } return builder; diff --git a/src/Microsoft.FeatureManagement/VariantServiceProvider.cs b/src/Microsoft.FeatureManagement/VariantServiceProvider.cs index d4b3f514..16293fb1 100644 --- a/src/Microsoft.FeatureManagement/VariantServiceProvider.cs +++ b/src/Microsoft.FeatureManagement/VariantServiceProvider.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. // +using Microsoft.Extensions.DependencyInjection; using System; using System.Collections.Concurrent; using System.Collections.Generic; @@ -16,7 +17,7 @@ namespace Microsoft.FeatureManagement /// internal class VariantServiceProvider : IVariantServiceProvider where TService : class { - private readonly IEnumerable _services; + private readonly IServiceProvider _serviceProvider; private readonly IVariantFeatureManager _featureManager; private readonly string _featureName; private readonly ConcurrentDictionary _variantServiceCache; @@ -26,15 +27,15 @@ internal class VariantServiceProvider : IVariantServiceProvider /// The feature flag that should be used to determine which variant of the service should be used. /// The feature manager to get the assigned variant of the feature flag. - /// Implementation variants of TService. + /// The service provider used to resolve implementation variants of TService. If it implements , keyed resolution is used to enable lazy instantiation; otherwise all registered implementations are enumerated. /// Thrown if is null. /// Thrown if is null. - /// Thrown if is null. - public VariantServiceProvider(string featureName, IVariantFeatureManager featureManager, IEnumerable services) + /// Thrown if is null. + public VariantServiceProvider(string featureName, IVariantFeatureManager featureManager, IServiceProvider serviceProvider) { _featureName = featureName ?? throw new ArgumentNullException(nameof(featureName)); _featureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager)); - _services = services ?? throw new ArgumentNullException(nameof(services)); + _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider)); _variantServiceCache = new ConcurrentDictionary(); } @@ -55,16 +56,35 @@ public async ValueTask GetServiceAsync(CancellationToken cancellationT { implementation = _variantServiceCache.GetOrAdd( variant.Name, - (_) => _services.FirstOrDefault( - service => IsMatchingVariantName( - service.GetType(), - variant.Name)) - ); + (variantName) => ResolveVariantService(variantName)); } return implementation; } + private TService ResolveVariantService(string variantName) + { + // + // If the service provider supports keyed services, try to resolve the variant by its name as the key first. + // This allows lazy instantiation of the variant service. + if (_serviceProvider is IKeyedServiceProvider) + { + TService keyedService = _serviceProvider.GetKeyedService(variantName); + + if (keyedService != null) + { + return keyedService; + } + } + + // + // Fall back to enumerating all non-keyed registrations of TService and matching by VariantServiceAliasAttribute or the implementation type name. + IEnumerable services = _serviceProvider.GetRequiredService>(); + + return services.FirstOrDefault( + service => IsMatchingVariantName(service.GetType(), variantName)); + } + private bool IsMatchingVariantName(Type implementationType, string variantName) { string implementationName = ((VariantServiceAliasAttribute)Attribute.GetCustomAttribute(implementationType, typeof(VariantServiceAliasAttribute)))?.Alias; diff --git a/tests/Tests.FeatureManagement/FeatureManagementTest.cs b/tests/Tests.FeatureManagement/FeatureManagementTest.cs index a70e6a0d..4219a518 100644 --- a/tests/Tests.FeatureManagement/FeatureManagementTest.cs +++ b/tests/Tests.FeatureManagement/FeatureManagementTest.cs @@ -524,12 +524,12 @@ public async Task MergesFeatureFlagsFromDifferentConfigurationSources() * Feature1: true * Feature2: true * FeatureA: true - * + * * appsettings2.json * Feature1: true * Feature2: false * FeatureB: true - * + * * appsettings3.json * Feature1: false * Feature2: false @@ -2234,6 +2234,157 @@ public async Task VariantBasedInjection() ); } + [Fact] + public async Task VariantServiceProviderResolvesKeyedService() + { + IConfiguration configuration = new ConfigurationBuilder() + .AddJsonFile("appsettings.json") + .Build(); + + IServiceCollection services = new ServiceCollection(); + + services.AddKeyedSingleton("AlgorithmBeta"); + services.AddKeyedSingleton("Sigma"); + services.AddKeyedSingleton("Omega", (sp, _) => new AlgorithmOmega("OMEGA")); + + services.AddSingleton(configuration) + .AddFeatureManagement() + .AddFeatureFilter() + .WithVariantService(Features.VariantImplementationFeature); + + var targetingContextAccessor = new OnDemandTargetingContextAccessor(); + + services.AddSingleton(targetingContextAccessor); + + ServiceProvider serviceProvider = services.BuildServiceProvider(); + + IVariantServiceProvider featuredAlgorithm = serviceProvider.GetRequiredService>(); + + targetingContextAccessor.Current = new TargetingContext { UserId = "UserBeta" }; + IAlgorithm algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.NotNull(algorithm); + Assert.Equal("Beta", algorithm.Style); + + targetingContextAccessor.Current = new TargetingContext { UserId = "UserSigma" }; + algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.NotNull(algorithm); + Assert.Equal("Sigma", algorithm.Style); + + targetingContextAccessor.Current = new TargetingContext { UserId = "UserOmega" }; + algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.NotNull(algorithm); + Assert.Equal("OMEGA", algorithm.Style); + } + + [Fact] + public async Task VariantServiceProviderKeyedServiceIsLazilyInstantiated() + { + IConfiguration configuration = new ConfigurationBuilder() + .AddJsonFile("appsettings.json") + .Build(); + + IServiceCollection services = new ServiceCollection(); + + int betaInstantiationCount = 0; + int sigmaInstantiationCount = 0; + int omegaInstantiationCount = 0; + + services.AddKeyedSingleton("AlgorithmBeta", (sp, _) => + { + betaInstantiationCount++; + return new AlgorithmBeta(); + }); + services.AddKeyedSingleton("Sigma", (sp, _) => + { + sigmaInstantiationCount++; + return new AlgorithmSigma(); + }); + services.AddKeyedSingleton("Omega", (sp, _) => + { + omegaInstantiationCount++; + return new AlgorithmOmega("OMEGA"); + }); + + services.AddSingleton(configuration) + .AddFeatureManagement() + .AddFeatureFilter() + .WithVariantService(Features.VariantImplementationFeature); + + var targetingContextAccessor = new OnDemandTargetingContextAccessor(); + + services.AddSingleton(targetingContextAccessor); + + ServiceProvider serviceProvider = services.BuildServiceProvider(); + + IVariantServiceProvider featuredAlgorithm = serviceProvider.GetRequiredService>(); + + // + // No variant resolved yet - nothing should be instantiated. + Assert.Equal(0, betaInstantiationCount); + Assert.Equal(0, sigmaInstantiationCount); + Assert.Equal(0, omegaInstantiationCount); + + // + // Resolve the Beta variant. Only AlgorithmBeta should be instantiated. + targetingContextAccessor.Current = new TargetingContext { UserId = "UserBeta" }; + IAlgorithm algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.Equal("Beta", algorithm.Style); + Assert.Equal(1, betaInstantiationCount); + Assert.Equal(0, sigmaInstantiationCount); + Assert.Equal(0, omegaInstantiationCount); + + // + // Resolving Beta again should reuse the cached instance - no new instantiation. + algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.Equal("Beta", algorithm.Style); + Assert.Equal(1, betaInstantiationCount); + Assert.Equal(0, sigmaInstantiationCount); + Assert.Equal(0, omegaInstantiationCount); + + // + // Resolve the Sigma variant. Only AlgorithmSigma should be instantiated additionally. + targetingContextAccessor.Current = new TargetingContext { UserId = "UserSigma" }; + algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.Equal("Sigma", algorithm.Style); + Assert.Equal(1, betaInstantiationCount); + Assert.Equal(1, sigmaInstantiationCount); + Assert.Equal(0, omegaInstantiationCount); + } + + [Fact] + public async Task VariantServiceProviderPrefersKeyedOverNonKeyed() + { + IConfiguration configuration = new ConfigurationBuilder() + .AddJsonFile("appsettings.json") + .Build(); + + IServiceCollection services = new ServiceCollection(); + + // + // Register both keyed and non-keyed implementations matching the same variant name. + // The keyed registration should take precedence. + services.AddSingleton(); + services.AddKeyedSingleton("AlgorithmBeta", (sp, _) => new AlgorithmOmega("KeyedBeta")); + + services.AddSingleton(configuration) + .AddFeatureManagement() + .AddFeatureFilter() + .WithVariantService(Features.VariantImplementationFeature); + + var targetingContextAccessor = new OnDemandTargetingContextAccessor(); + + services.AddSingleton(targetingContextAccessor); + + ServiceProvider serviceProvider = services.BuildServiceProvider(); + + IVariantServiceProvider featuredAlgorithm = serviceProvider.GetRequiredService>(); + + targetingContextAccessor.Current = new TargetingContext { UserId = "UserBeta" }; + IAlgorithm algorithm = await featuredAlgorithm.GetServiceAsync(CancellationToken.None); + Assert.NotNull(algorithm); + Assert.Equal("KeyedBeta", algorithm.Style); + } + [Fact] public async Task VariantFeatureFlagWithContextualFeatureFilter() {