Add support for IKeyedServiceProvider.

src/Ninject.Web.AspNetCore.Test/Unit/ServiceProviderKeyedTest.cs

@@ -0,0 +1,214 @@
+using AwesomeAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Ninject.Web.AspNetCore.Test.Fakes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Ninject.Web.AspNetCore.Test.Unit
+{
+
+#if NET8_0_OR_GREATER
+
+	public class ServiceProviderKeyedTest
+	{
+
+		[Fact]
+		public void OptionalKeyedServiceCollectionExisting_CorrectServiceResolved()
+		{
+			var collection = new ServiceCollection();
+			collection.Add(new ServiceDescriptor(typeof(IWarrior),"Samurai", typeof(Samurai), ServiceLifetime.Transient));
+			collection.Add(new ServiceDescriptor(typeof(IWarrior), "Ninja1", new Ninja("test")));
+			collection.Add(new ServiceDescriptor(typeof(IWarrior),"Ninja2",
+				(provider, key) => new Ninja("test:" + key.ToString()), ServiceLifetime.Transient));
+			var kernel = CreateTestKernel(collection);
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetKeyedService(typeof(IWarrior), "Samurai").Should().NotBeNull().And.BeOfType(typeof(Samurai));
+			provider.GetKeyedService(typeof(IWarrior), "Ninja1").Should().NotBeNull().And.BeOfType(typeof(Ninja)).
+				And.Match(x => ((Ninja)x).Name == "test");
+			var ninja2First = provider.GetKeyedService(typeof(IWarrior), "Ninja2");
+			var ninja2Second = provider.GetKeyedService(typeof(IWarrior), "Ninja2");
+			ninja2First.Should().NotBeNull().And.BeOfType(typeof(Ninja)).
+				And.Match(x => ((Ninja)x).Name == "test:Ninja2");
+			ninja2Second.Should().NotBeNull().And.BeOfType(typeof(Ninja)).
+				And.Match(x => ((Ninja)x).Name == "test:Ninja2");
+			ninja2First.Should().NotBeSameAs(ninja2Second);
+		}
+
+		[Fact]
+		public void OptionalKeyedNinjectDirectBindingExisting_CorrectServiceResolved()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetKeyedService(typeof(IWarrior), "Samurai").Should().NotBeNull().And.BeOfType(typeof(Samurai));
+			provider.GetKeyedService(typeof(IWarrior), "Ninja").Should().NotBeNull().And.BeOfType(typeof(Ninja));
+		}
+
+		[Fact]
+		public void OptionalKeyedNonExisting_SingleServiceResolvedToNull()
+		{
+			var kernel = CreateTestKernel();
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetKeyedService(typeof(IWarrior), "Samurai").Should().BeNull();
+		}
+
+		[Fact]
+		public void OptionalExistingMultipleKeydServices_ResolvedQueriedAsList()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Warrior"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Warrior"));
+			var provider = CreateServiceProvider(kernel);
+
+			var result = provider.GetKeyedService(typeof(IList<IWarrior>), "Warrior") as IEnumerable<IWarrior>;
+
+			result.Should().NotBeNull();
+			var resultList = result.ToList();
+			resultList.Should().HaveCount(2);
+			resultList.Should().Contain(x => x is Samurai);
+			resultList.Should().Contain(x => x is Ninja);
+		}
+
+		[Fact]
+		public void OptionalExistingMultipleKeydServices_NotResolvedAsListNonKeyed()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			var result = provider.GetService(typeof(IList<IWarrior>)) as IEnumerable<IWarrior>;
+
+			result.Should().NotBeNull();
+			var resultList = result.ToList();
+			resultList.Should().HaveCount(0);
+		}
+
+		[Fact]
+		public void ExistingMultipleServices_ResolvesNonKeyedToNull()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetService(typeof(IWarrior)).Should().BeNull();
+		}
+
+		[Fact]
+		public void RequiredKeyedServiceCollectionExisting_CorrectServiceResolved()
+		{
+			var collection = new ServiceCollection();
+			collection.Add(new ServiceDescriptor(typeof(IWarrior),"Samurai", typeof(Samurai), ServiceLifetime.Transient));
+			collection.Add(new ServiceDescriptor(typeof(IWarrior), "Ninja", new Ninja("test")));
+			var kernel = CreateTestKernel(collection);
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetRequiredKeyedService(typeof(IWarrior), "Ninja").Should().NotBeNull().And.BeOfType(typeof(Ninja));
+			provider.GetRequiredKeyedService(typeof(IWarrior), "Samurai").Should().NotBeNull().And.BeOfType(typeof(Samurai));
+
+		}
+
+		[Fact]
+		public void RequiredKeyedNinjectDirectBindingExisting_CorrectServiceResolved()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			provider.GetRequiredKeyedService(typeof(IWarrior), "Samurai").Should().NotBeNull().And.BeOfType(typeof(Samurai));
+			provider.GetRequiredKeyedService(typeof(IWarrior), "Ninja").Should().NotBeNull().And.BeOfType(typeof(Ninja));
+		}
+
+		[Fact]
+		public void RequiredKeyedNonExisting_SingleServiceResolvedToException()
+		{
+			var kernel = CreateTestKernel();
+			var provider = CreateServiceProvider(kernel);
+
+			Action action = () => provider.GetRequiredKeyedService(typeof(IWarrior), "Samurai");
+			action.Should().Throw<ActivationException>().WithMessage("*No matching bindings are available*");
+		}
+
+		[Fact]
+		public void RequiredExistingMultipleKeydServices_ResolvedQueriedAsList()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Warrior"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Warrior"));
+			var provider = CreateServiceProvider(kernel);
+
+			var result = provider.GetRequiredKeyedService(typeof(IList<IWarrior>), "Warrior") as IEnumerable<IWarrior>;
+
+			result.Should().NotBeNull();
+			var resultList = result.ToList();
+			resultList.Should().HaveCount(2);
+			resultList.Should().Contain(x => x is Samurai);
+			resultList.Should().Contain(x => x is Ninja);
+		}
+
+		[Fact]
+		public void RequiredExistingMultipleKeydServices_NotResolvedAsListNonKeyed()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			var result = provider.GetRequiredService(typeof(IList<IWarrior>)) as IEnumerable<IWarrior>;
+
+			result.Should().NotBeNull();
+			var resultList = result.ToList();
+			resultList.Should().HaveCount(0);
+		}
+
+		[Fact]
+		public void ExistingMultipleServices_ResolvesNonKeyedToException()
+		{
+			var kernel = CreateTestKernel();
+			kernel.Bind<IWarrior>().To<Samurai>().WithMetadata(nameof(ServiceKey), new ServiceKey("Samurai"));;
+			kernel.Bind<IWarrior>().ToConstant(new Ninja("test")).WithMetadata(nameof(ServiceKey), new ServiceKey("Ninja"));
+			var provider = CreateServiceProvider(kernel);
+
+			Action action = () => provider.GetRequiredService(typeof(IWarrior));
+			action.Should().Throw<ActivationException>().WithMessage("*More than one matching bindings are available*");
+		}
+
+		private IServiceProvider CreateServiceProvider(AspNetCoreKernel kernel)
+		{
+			NinjectServiceProviderBuilder builder = CreateServiceProviderBuilder(kernel);
+			var provider = builder.Build();
+			return provider;
+		}
+
+		private NinjectServiceProviderBuilder CreateServiceProviderBuilder(AspNetCoreKernel kernel)
+		{
+			var collection = new ServiceCollection();
+			var factory = new NinjectServiceProviderFactory(kernel);
+			var builder = factory.CreateBuilder(collection);
+			return builder;
+		}
+
+		private AspNetCoreKernel CreateTestKernel(IServiceCollection collection = null)
+		{
+			var kernel = new AspNetCoreKernel(new NinjectSettings() { LoadExtensions = false });
+			kernel.Load(typeof(AspNetCoreApplicationPlugin).Assembly);
+			if (collection != null)
+			{
+				new ServiceCollectionAdapter().Populate(kernel, collection);
+			}
+
+			return kernel;
+		}
+
+	}
+#endif
+}

src/Ninject.Web.AspNetCore/DefaultDescriptorAdapter.cs

@@ -0,0 +1,28 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Ninject.Web.AspNetCore
+{
+	/// <summary>
+	/// This ServiceDescriptorAdapter is used when ServiceDescriptor.IsKeyedService == false
+	/// This was always the case before .NET 8.0
+	/// </summary>
+	public class DefaultDescriptorAdapter : IDescriptorAdapter
+	{
+		private ServiceDescriptor _descriptor;
+
+		public DefaultDescriptorAdapter(ServiceDescriptor descriptor)
+		{
+			_descriptor = descriptor;
+		}
+
+		public Type ImplementationType => _descriptor.ImplementationType;
+		public object ImplementationInstance => _descriptor.ImplementationInstance;
+		public bool UseServiceFactory => _descriptor.ImplementationFactory != null;
+		public object InstantiateFromServiceFactory(IServiceProvider provider)
+		{
+			return _descriptor.ImplementationFactory(provider);
+		}
+		public ServiceLifetime Lifetime => _descriptor.Lifetime;
+	}
+}

src/Ninject.Web.AspNetCore/IDescriptorAdapter.cs

@@ -0,0 +1,37 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Ninject.Web.AspNetCore
+{
+	/// <summary>
+	/// This interface allows to handle the differences between keyed and non keyed implementation instruction
+	/// on ServiceDescriptors
+	/// </summary>
+	public interface IDescriptorAdapter
+	{
+		/// <summary>
+		/// Returns the type to instantiate if instantiation should be done by type.
+		/// </summary>
+		Type ImplementationType { get; }
+
+		/// <summary>
+		/// Returns the instance if a specific instance is configured on the descriptor
+		/// </summary>
+		object ImplementationInstance { get; }
+
+		/// <summary>
+		/// Returns true, if a service factory is configured on the descriptor
+		/// </summary>
+		bool UseServiceFactory { get; }
+
+		/// <summary>
+		/// If UseServiceFactory returns true, use this method to instantiate via factory.
+		/// </summary>
+		object InstantiateFromServiceFactory(IServiceProvider provider);
+
+		/// <summary>
+		/// The lifetime coonfigured for the service descriptor
+		/// </summary>
+		ServiceLifetime  Lifetime { get; }
+	}
+}

src/Ninject.Web.AspNetCore/KeyedDescriptorAdapter.cs

@@ -0,0 +1,31 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Ninject.Web.AspNetCore
+{
+#if NET8_0_OR_GREATER
+	/// <summary>
+	/// This ServiceDescriptorAdapter is used when ServiceDescriptor.IsKeyedService == true
+	/// </summary>
+	public class KeyedDescriptorAdapter : IDescriptorAdapter
+	{
+
+		private ServiceDescriptor _descriptor;
+
+		public KeyedDescriptorAdapter(ServiceDescriptor descriptor)
+		{
+			_descriptor = descriptor;
+		}
+
+		public Type ImplementationType => _descriptor.KeyedImplementationType;
+		public object ImplementationInstance => _descriptor.KeyedImplementationInstance;
+		public bool UseServiceFactory => _descriptor.KeyedImplementationFactory != null;
+		public object InstantiateFromServiceFactory(IServiceProvider provider)
+		{
+			return _descriptor.KeyedImplementationFactory(provider, _descriptor.ServiceKey);
+		}
+
+		public ServiceLifetime Lifetime => _descriptor.Lifetime;
+	}
+#endif
+}