feat: Add DI for multi provider

samples/AspNetCore/Program.cs

@@ -7,6 +7,7 @@
 using OpenFeature.Model;
 using OpenFeature.Providers.Memory;
 using OpenFeature.Providers.MultiProvider;
+using OpenFeature.Providers.MultiProvider.DependencyInjection;
 using OpenFeature.Providers.MultiProvider.Models;
 using OpenFeature.Providers.MultiProvider.Strategies;
 using OpenTelemetry.Metrics;
@@ -59,7 +60,28 @@
                     { "disable", new Value(Structure.Builder().Set(nameof(TestConfig.Threshold), 0).Build()) }
                 }, "disable")
             }
-        });
+        })
+        .AddMultiProvider("multi-provider", multiProviderBuilder =>
+        {
+            // Create provider flags
+            var provider1Flags = new Dictionary<string, Flag>
+            {
+                { "providername", new Flag<string>(new Dictionary<string, string> { { "enabled", "enabled-provider1" }, { "disabled", "disabled-provider1" } }, "enabled") },
+                { "max-items", new Flag<int>(new Dictionary<string, int> { { "low", 10 }, { "high", 100 } }, "high") },
+            };
+
+            var provider2Flags = new Dictionary<string, Flag>
+            {
+                { "providername", new Flag<string>(new Dictionary<string, string> { { "enabled", "enabled-provider2" }, { "disabled", "disabled-provider2" } }, "enabled") },
+            };
+
+            // Use the factory pattern to create providers - they will be properly initialized
+            multiProviderBuilder
+                .AddProvider("p1", sp => new InMemoryProvider(provider1Flags))
+                .AddProvider("p2", sp => new InMemoryProvider(provider2Flags))
+                .UseStrategy<FirstMatchStrategy>();
+        })
+        .AddPolicyName(policy => policy.DefaultNameSelector = provider => "InMemory");
 });
 
 var app = builder.Build();
@@ -139,6 +161,27 @@
     }
 });
 
+app.MapGet("/multi-provider-di", async ([FromServices] Api openFeatureApi) =>
+{
+    try
+    {
+        var featureClient = openFeatureApi.GetClient("multi-provider");
+
+        // Test flag evaluation from different providers
+        var maxItemsFlag = await featureClient.GetIntegerDetailsAsync("max-items", 0);
+        var providerNameFlag = await featureClient.GetStringDetailsAsync("providername", "default");
+
+        // Test a flag that doesn't exist in any provider
+        var unknownFlag = await featureClient.GetBooleanDetailsAsync("unknown-flag", false);
+
+        return Results.Ok();
+    }
+    catch (Exception ex)
+    {
+        return Results.Problem($"Error: {ex.Message}\n\nStack: {ex.StackTrace}");
+    }
+});
+
 app.Run();
 
 

src/OpenFeature.Providers.MultiProvider/DependencyInjection/FeatureBuilderExtensions.cs

@@ -0,0 +1,94 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using OpenFeature.Hosting;
+
+namespace OpenFeature.Providers.MultiProvider.DependencyInjection;
+
+/// <summary>
+/// Extension methods for configuring the multi-provider with <see cref="OpenFeatureBuilder"/>.
+/// </summary>
+public static class FeatureBuilderExtensions
+{
+    /// <summary>
+    /// Adds a multi-provider to the <see cref="OpenFeatureBuilder"/> with a configuration builder.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <param name="configure">
+    /// A delegate to configure the multi-provider using the <see cref="MultiProviderBuilder"/>.
+    /// </param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddMultiProvider(
+        this OpenFeatureBuilder builder,
+        Action<MultiProviderBuilder> configure)
+    {
+        if (builder == null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (configure == null)
+        {
+            throw new ArgumentNullException(nameof(configure));
+        }
+
+        return builder.AddProvider(
+            serviceProvider => CreateMultiProviderFromConfigure(serviceProvider, configure));
+    }
+
+    /// <summary>
+    /// Adds a multi-provider with a specific domain to the <see cref="OpenFeatureBuilder"/> with a configuration builder.
+    /// </summary>
+    /// <param name="builder">The <see cref="OpenFeatureBuilder"/> instance to configure.</param>
+    /// <param name="domain">The unique domain of the provider.</param>
+    /// <param name="configure">
+    /// A delegate to configure the multi-provider using the <see cref="MultiProviderBuilder"/>.
+    /// </param>
+    /// <returns>The <see cref="OpenFeatureBuilder"/> instance for chaining.</returns>
+    public static OpenFeatureBuilder AddMultiProvider(
+        this OpenFeatureBuilder builder,
+        string domain,
+        Action<MultiProviderBuilder> configure)
+    {
+        if (builder == null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        if (string.IsNullOrWhiteSpace(domain))
+        {
+            throw new ArgumentException("Domain cannot be null or empty.", nameof(domain));
+        }
+
+        if (configure == null)
+        {
+            throw new ArgumentNullException(nameof(configure));
+        }
+
+        return builder.AddProvider(
+            domain,
+            (serviceProvider, _) => CreateMultiProviderFromConfigure(serviceProvider, configure));
+    }
+
+    private static MultiProvider CreateMultiProviderFromConfigure(IServiceProvider serviceProvider, Action<MultiProviderBuilder> configure)
+    {
+        // Build the multi-provider configuration using the builder
+        var multiProviderBuilder = new MultiProviderBuilder();
+
+        // Apply the configuration action
+        configure(multiProviderBuilder);
+
+        // Build provider entries and strategy from the builder using the service provider
+        var providerEntries = multiProviderBuilder.BuildProviderEntries(serviceProvider);
+        var evaluationStrategy = multiProviderBuilder.BuildEvaluationStrategy(serviceProvider);
+
+        if (providerEntries.Count == 0)
+        {
+            throw new InvalidOperationException("At least one provider must be configured for the multi-provider.");
+        }
+
+        // Get logger from DI
+        var logger = serviceProvider.GetService<ILogger<MultiProvider>>();
+
+        return new MultiProvider(providerEntries, evaluationStrategy, logger);
+    }
+}

src/OpenFeature.Providers.MultiProvider/DependencyInjection/MultiProviderBuilder.cs

@@ -0,0 +1,139 @@
+using Microsoft.Extensions.DependencyInjection;
+using OpenFeature.Providers.MultiProvider.Models;
+using OpenFeature.Providers.MultiProvider.Strategies;
+
+namespace OpenFeature.Providers.MultiProvider.DependencyInjection;
+
+/// <summary>
+/// Builder for configuring a multi-provider with dependency injection.
+/// </summary>
+public class MultiProviderBuilder
+{
+    private readonly List<Func<IServiceProvider, ProviderEntry>> _providerFactories = [];
+    private Func<IServiceProvider, BaseEvaluationStrategy>? _strategyFactory;
+
+    /// <summary>
+    /// Adds a provider to the multi-provider configuration using a factory method.
+    /// </summary>
+    /// <param name="name">The name for the provider.</param>
+    /// <param name="factory">A factory method to create the provider instance.</param>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder AddProvider(string name, Func<IServiceProvider, FeatureProvider> factory)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            throw new ArgumentException("Provider name cannot be null or empty.", nameof(name));
+        }
+
+        if (factory == null)
+        {
+            throw new ArgumentNullException(nameof(factory));
+        }
+
+        this._providerFactories.Add(sp => new ProviderEntry(factory(sp), name));
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a provider to the multi-provider configuration using a type.
+    /// </summary>
+    /// <typeparam name="TProvider">The type of the provider to add.</typeparam>
+    /// <param name="name">The name for the provider.</param>
+    /// <param name="factory">An optional factory method to create the provider instance. If not provided, the provider will be resolved from the service provider.</param>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder AddProvider<TProvider>(string name, Func<IServiceProvider, TProvider>? factory = null)
+        where TProvider : FeatureProvider
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            throw new ArgumentException("Provider name cannot be null or empty.", nameof(name));
+        }
+
+        this._providerFactories.Add(sp =>
+        {
+            var provider = factory != null
+                ? factory(sp)
+                : sp.GetRequiredService<TProvider>();
+            return new ProviderEntry(provider, name);
+        });
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a provider instance to the multi-provider configuration.
+    /// </summary>
+    /// <param name="name">The name for the provider.</param>
+    /// <param name="provider">The provider instance to add.</param>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder AddProvider(string name, FeatureProvider provider)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            throw new ArgumentException("Provider name cannot be null or empty.", nameof(name));
+        }
+
+        if (provider == null)
+        {
+            throw new ArgumentNullException(nameof(provider));
+        }
+
+        this._providerFactories.Add(_ => new ProviderEntry(provider, name));
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the evaluation strategy for the multi-provider.
+    /// </summary>
+    /// <typeparam name="TStrategy">The type of the evaluation strategy.</typeparam>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder UseStrategy<TStrategy>()
+        where TStrategy : BaseEvaluationStrategy, new()
+    {
+        this._strategyFactory = _ => new TStrategy();
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the evaluation strategy for the multi-provider using a factory method.
+    /// </summary>
+    /// <param name="factory">A factory method to create the strategy instance.</param>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder UseStrategy(Func<IServiceProvider, BaseEvaluationStrategy> factory)
+    {
+        this._strategyFactory = factory ?? throw new ArgumentNullException(nameof(factory));
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the evaluation strategy for the multi-provider.
+    /// </summary>
+    /// <param name="strategy">The strategy instance to use.</param>
+    /// <returns>The <see cref="MultiProviderBuilder"/> instance for chaining.</returns>
+    public MultiProviderBuilder UseStrategy(BaseEvaluationStrategy strategy)
+    {
+        if (strategy == null)
+        {
+            throw new ArgumentNullException(nameof(strategy));
+        }
+
+        this._strategyFactory = _ => strategy;
+        return this;
+    }
+
+    /// <summary>
+    /// Builds the provider entries using the service provider.
+    /// </summary>
+    internal List<ProviderEntry> BuildProviderEntries(IServiceProvider serviceProvider)
+    {
+        return this._providerFactories.Select(factory => factory(serviceProvider)).ToList();
+    }
+
+    /// <summary>
+    /// Builds the evaluation strategy using the service provider.
+    /// </summary>
+    internal BaseEvaluationStrategy? BuildEvaluationStrategy(IServiceProvider serviceProvider)
+    {
+        return this._strategyFactory?.Invoke(serviceProvider);
+    }
+}

src/OpenFeature.Providers.MultiProvider/OpenFeature.Providers.MultiProvider.csproj

@@ -1,17 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-    <PropertyGroup>
-        <RootNamespace>OpenFeature.Providers.MultiProvider</RootNamespace>
-        <PackageReadmeFile>README.md</PackageReadmeFile>
-    </PropertyGroup>
+  <PropertyGroup>
+    <RootNamespace>OpenFeature.Providers.MultiProvider</RootNamespace>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+  </PropertyGroup>
 
-    <ItemGroup>
-        <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
-        <InternalsVisibleTo Include="OpenFeature.Providers.MultiProvider.Tests" />
-        <None Include="README.md" Pack="true" PackagePath="/" />
-    </ItemGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+    <InternalsVisibleTo Include="OpenFeature.Providers.MultiProvider.Tests" />
+    <None Include="README.md" Pack="true" PackagePath="/" />
+  </ItemGroup>
 
-    <ItemGroup>
-        <ProjectReference Include="..\OpenFeature\OpenFeature.csproj" />
-    </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\OpenFeature\OpenFeature.csproj" />
+    <ProjectReference Include="..\OpenFeature.Hosting\OpenFeature.Hosting.csproj" />
+  </ItemGroup>
 </Project>

test/OpenFeature.AotCompatibility/OpenFeature.AotCompatibility.csproj

@@ -18,7 +18,7 @@
 
     <ItemGroup>
         <ProjectReference Include="..\..\src\OpenFeature\OpenFeature.csproj" />
-        <ProjectReference Include="..\..\src\OpenFeature.DependencyInjection\OpenFeature.DependencyInjection.csproj" />
+        <ProjectReference Include="..\..\src\OpenFeature.Hosting\OpenFeature.Hosting.csproj" />
         <ProjectReference Include="..\..\src\OpenFeature.Providers.MultiProvider\OpenFeature.Providers.MultiProvider.csproj" />
     </ItemGroup>