update to the latest design

Author: zhiyuanliang-ms

examples/FeatureBasedInjectionPOC/AlgorithmOmega.cs

@@ -7,9 +7,9 @@ class AlgorithmOmega : IAlgorithm
     {
         public string Name { get; set; }
 
-        public AlgorithmOmega()
+        public AlgorithmOmega(string name)
         {
-            Name = "Omega";
+            Name = name;
         }
     }
 }

examples/FeatureBasedInjectionPOC/Program.cs

@@ -11,11 +11,15 @@
 
 IServiceCollection services = new ServiceCollection();
 
+services.AddSingleton<IAlgorithm, AlgorithmAlpha>();
+services.AddSingleton<IAlgorithm, AlgorithmBeta>();
+services.AddSingleton<IAlgorithm, AlgorithmSigma>();
+services.AddSingleton<IAlgorithm>(sp => new AlgorithmOmega("Omega"));
+
 services.AddSingleton(configuration)
         .AddFeatureManagement()
-        .AddFeatureFilter<TargetingFilter>();
-
-services.AddSingletonForFeature<IAlgorithm>("MyFeature");
+        .AddFeatureFilter<TargetingFilter>()
+        .AddFeaturedService<IAlgorithm>("MyFeature");
 
 var targetingContextAccessor = new OnDemandTargetingContextAccessor();
 

src/Microsoft.FeatureManagement/FeatureManagementBuilderExtensions.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 
 namespace Microsoft.FeatureManagement
 {
@@ -16,6 +17,32 @@ namespace Microsoft.FeatureManagement
     /// </summary>
     public static class FeatureManagementBuilderExtensions
     {
+        /// <summary>
+        /// Adds a <see cref="FeaturedService{TService}"/> to the feature management system.
+        /// </summary>
+        /// <param name="builder">The <see cref="IFeatureManagementBuilder"/> used to customize feature management functionality.</param>
+        /// <param name="featureName">The variant feature flag used to assign variants. The <see cref="FeaturedService{TService}"/> will return different implementations of TService according to the assigned variant.</param>
+        /// <returns>A <see cref="IFeatureManagementBuilder"/> that can be used to customize feature management functionality.</returns>
+        public static IFeatureManagementBuilder AddFeaturedService<TService>(this IFeatureManagementBuilder builder, string featureName) where TService : class
+        {
+            if (builder.Services.Any(descriptor => descriptor.ServiceType == typeof(IFeatureManager) && descriptor.Lifetime == ServiceLifetime.Scoped))
+            {
+                builder.Services.AddScoped<IFeaturedService<TService>>(sp => new FeaturedService<TService>(
+                    featureName,
+                    sp.GetRequiredService<IEnumerable<TService>>(),
+                    sp.GetRequiredService<IVariantFeatureManager>()));
+            }
+            else
+            {
+                builder.Services.AddSingleton<IFeaturedService<TService>>(sp => new FeaturedService<TService>(
+                    featureName,
+                    sp.GetRequiredService<IEnumerable<TService>>(),
+                    sp.GetRequiredService<IVariantFeatureManager>()));
+            }
+
+            return builder;
+        }
+
         /// <summary>
         /// Adds a telemetry publisher to the feature management system.
         /// </summary>

src/Microsoft.FeatureManagement/FeaturedService.cs

@@ -12,35 +12,32 @@ namespace Microsoft.FeatureManagement
 {
     internal class FeaturedService<TService> : IFeaturedService<TService> where TService : class
     {
-        private string _featureName;
-        private IVariantFeatureManager _featureManager;
-        private IEnumerable<FeaturedServiceImplementationWrapper<TService>> _services;
+        private readonly string _featureName;
+        private readonly IVariantFeatureManager _featureManager;
+        private readonly IEnumerable<TService> _services;
 
-        public FeaturedService(string featureName, IEnumerable<FeaturedServiceImplementationWrapper<TService>> services, IVariantFeatureManager featureManager)
+        public FeaturedService(string featureName, IEnumerable<TService> services, IVariantFeatureManager featureManager)
         {
             _featureName = featureName;
-            _services = services.Where(s => s.FeatureName.Equals(featureName));
+            _services = services;
             _featureManager = featureManager;
         }
 
         public async ValueTask<TService> GetAsync(CancellationToken cancellationToken)
         {
             Variant variant = await _featureManager.GetVariantAsync(_featureName, cancellationToken);
 
+            TService implementation = null;
+
             if (variant != null)
             {
-                FeaturedServiceImplementationWrapper<TService> implementationWrapper = _services.FirstOrDefault(s => 
+                implementation = _services.FirstOrDefault(service => 
                     IsMatchingVariant(
-                        s.Implementation.GetType(),
+                        service.GetType(),
                         variant));
-
-                if (implementationWrapper != null)
-                {
-                    return implementationWrapper.Implementation;
-                }
             }
 
-            return null;
+            return implementation;
         }
 
         private bool IsMatchingVariant(Type implementationType, Variant variant)

src/Microsoft.FeatureManagement/FeaturedServiceImplementationWrapper.cs

@@ -194,44 +194,5 @@ public static IFeatureManagementBuilder AddScopedFeatureManagement(this IService
 
             return services.AddScopedFeatureManagement();
         }
-
-        public static IServiceCollection AddSingletonForFeature<TService>(this IServiceCollection services, string featureName) where TService : class
-        {
-            IEnumerable<Type> implementationTypes = Assembly.GetAssembly(typeof(TService))
-                .GetTypes()
-                .Where(type => 
-                    typeof(TService).IsAssignableFrom(type) && 
-                    !type.IsInterface && 
-                    !type.IsAbstract);
-
-            foreach (var implementationType in implementationTypes)
-            {
-                services.TryAddSingleton(implementationType);
-
-                services.AddSingleton(sp => new FeaturedServiceImplementationWrapper<TService>()
-                {
-                    FeatureName = featureName,
-                    Implementation = (TService) sp.GetRequiredService(implementationType)
-                });
-            }
-
-
-            if (services.Any(descriptor => descriptor.ServiceType == typeof(IFeatureManager) && descriptor.Lifetime == ServiceLifetime.Scoped))
-            {
-                services.AddScoped<IFeaturedService<TService>>(sp => new FeaturedService<TService>(
-                    featureName,
-                    sp.GetRequiredService<IEnumerable<FeaturedServiceImplementationWrapper<TService>>>(),
-                    sp.GetRequiredService<IVariantFeatureManager>()));
-            }
-            else
-            {
-                services.AddSingleton<IFeaturedService<TService>>(sp => new FeaturedService<TService>(
-                    featureName,
-                    sp.GetRequiredService<IEnumerable<FeaturedServiceImplementationWrapper<TService>>>(),
-                    sp.GetRequiredService<IVariantFeatureManager>()));
-            }
-
-            return services;
-        }
     }
 }