Keyed Dictionary Support

src/OrchardCore.Cms.Web/Program.cs

@@ -1,8 +1,11 @@
+using OrchardCore.DependencyInjection;
 using OrchardCore.Logging;
 
 var builder = WebApplication.CreateBuilder(args);
 
-builder.Host.UseNLogHost();
+builder.Host
+    .UseOrchardCoreHost()
+    .UseNLogHost();
 
 builder.Services
     .AddOrchardCms()

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/DependencyInjection/Extensions/ServiceProviderExtensions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using OrchardCore.DependencyInjection;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class ServiceProviderExtensions
+{
+    public static IReadOnlyDictionary<object, TKeyedService> GetKeyedServiceDictionary<TKeyedService>(this IServiceProvider serviceProvider)
+    {
+        var keys = serviceProvider.GetRequiredService<Keys<TKeyedService>>();
+
+        var keyedDictionary = new Dictionary<object, TKeyedService>(keys.Count);
+        var keyedDictionaryWrapper = new ReadOnlyDictionary<object, TKeyedService>(keyedDictionary);
+
+        foreach (var key in keys)
+        {
+            var service = serviceProvider.GetKeyedService<TKeyedService>(key);
+
+            keyedDictionary.Add(key, service);
+        }
+
+        return keyedDictionaryWrapper;
+    }
+}

src/OrchardCore/OrchardCore.Infrastructure.Abstractions/DependencyInjection/Keys.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace OrchardCore.DependencyInjection;
+
+public class Keys<T> : List<object>
+{
+    public Keys(IEnumerable<object> collection) : base(collection)
+    {
+    }
+}

src/OrchardCore/OrchardCore.Infrastructure/DependencyInjection/Extensions/HostBuilderExtensions.cs

@@ -0,0 +1,9 @@
+using Microsoft.Extensions.Hosting;
+
+namespace OrchardCore.DependencyInjection;
+
+public static class HostBuilderExtensions
+{
+    public static IHostBuilder UseOrchardCoreHost(this IHostBuilder builder)
+        => builder.UseServiceProviderFactory(new OrchardCoreServiceProviderFactory());
+}

src/OrchardCore/OrchardCore.Infrastructure/DependencyInjection/OrchardCoreServiceProviderFactory.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace OrchardCore.DependencyInjection;
+
+public class OrchardCoreServiceProviderFactory : IServiceProviderFactory<IServiceCollection>
+{
+    public IServiceCollection CreateBuilder(IServiceCollection services) => services;
+
+    public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)
+    {
+        var keyedDictionary = new Dictionary<Type, List<object>>();
+
+        foreach (var service in containerBuilder)
+        {
+            if (service.ServiceKey != null)
+            {
+                if (!keyedDictionary.TryGetValue(service.ServiceType, out var keysList))
+                {
+                    keysList = [];
+                    keyedDictionary[service.ServiceType] = keysList;
+                }
+
+                keysList.Add(service.ServiceKey);
+            }
+        }
+
+        AddKeysService(containerBuilder, keyedDictionary);
+
+        containerBuilder.AddSingleton(typeof(Keys<>));
+
+        return containerBuilder.BuildServiceProvider();
+    }
+
+    private static void AddKeysService(IServiceCollection services, IDictionary<Type, List<object>> keyedDictionary)
+    {
+        foreach (var keyedDictionaryItem in keyedDictionary)
+        {
+            var serviceType = typeof(Keys<>).MakeGenericType(keyedDictionaryItem.Key);
+            var service = Activator.CreateInstance(serviceType, keyedDictionaryItem.Value);
+
+            services.AddSingleton(serviceType, service!);
+        }
+    }
+}

test/OrchardCore.Tests/DependencyInjection/Extensions/ServiceProviderExtensionsTests.cs

@@ -0,0 +1,30 @@
+namespace OrchardCore.DependencyInjection.Tests;
+
+public class ServiceProviderExtensionsTests
+{
+    [Fact]
+    public void ResolveKeyedServiceDictionary()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddSingleton(new FooService());
+        services.AddKeyedSingleton("foo", new FooService());
+        services.AddKeyedSingleton("bar", new FooService());
+        services.AddKeyedSingleton("baz", new FooService());
+
+        var serviceProviderFactory = new OrchardCoreServiceProviderFactory();
+        var serviceProvider = serviceProviderFactory.CreateServiceProvider(services);
+
+        // Act
+        var keyedDictionary = serviceProvider.GetKeyedServiceDictionary<FooService>();
+
+        // Assert
+        Assert.Equal(3, keyedDictionary.Count);
+        Assert.Contains(keyedDictionary, item => item.Key.Equals("foo"));
+        Assert.Contains(keyedDictionary, item => item.Key.Equals("bar"));
+        Assert.Contains(keyedDictionary, item => item.Key.Equals("baz"));
+        Assert.IsType<FooService>(keyedDictionary["foo"]);
+        Assert.IsType<FooService>(keyedDictionary["bar"]);
+        Assert.IsType<FooService>(keyedDictionary["baz"]);
+    }
+}

test/OrchardCore.Tests/DependencyInjection/FooService.cs

@@ -0,0 +1,5 @@
+namespace OrchardCore.DependencyInjection.Tests;
+
+internal class FooService
+{
+}

test/OrchardCore.Tests/DependencyInjection/OrchardCoreServiceProviderFactoryTests.cs

@@ -0,0 +1,26 @@
+namespace OrchardCore.DependencyInjection.Tests;
+
+public class OrchardCoreServiceProviderFactoryTests
+{
+    [Fact]
+    public void ResolveKeys()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+        services.AddSingleton(new FooService());
+        services.AddKeyedSingleton("foo", new FooService());
+        services.AddKeyedSingleton("bar", new FooService());
+        services.AddKeyedSingleton("baz", new FooService());
+
+        // Act
+        var serviceProviderFactory = new OrchardCoreServiceProviderFactory();
+        var serviceProvider = serviceProviderFactory.CreateServiceProvider(services);
+
+        // Assert
+        var keys = serviceProvider.GetRequiredService<Keys<FooService>>();
+        Assert.Equal(3, keys.Count);
+        Assert.Equal("foo", keys[0]);
+        Assert.Equal("bar", keys[1]);
+        Assert.Equal("baz", keys[2]);
+    }
+}