handle special cases with AnyKey as well as with null key

Author: DominicUllmann

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

@@ -14,6 +14,19 @@ namespace Ninject.Web.AspNetCore.Test.Unit
 
 	public class ServiceProviderKeyedTest
 	{
+
+		[Fact]
+		public void OptionalExising_ServiceKeyNullResolvedAsUnkeyed()
+		{
+			var collection = new ServiceCollection();
+			collection.Add(new ServiceDescriptor(typeof(IWarrior),null, typeof(Samurai), ServiceLifetime.Transient));
+			var kernel = CreateTestKernel(collection);
+			var provider = CreateServiceProvider(kernel);
+
+			var warrior = provider.GetKeyedService(typeof(Samurai), null);
+			warrior.Should().NotBeNull().And.BeOfType(typeof(Samurai));
+		}
+
 		[Fact]
 		public void OptionalExising_SingleServiceInjectedServiceKeyResolved()
 		{

src/Ninject.Web.AspNetCore/BindingIndex.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Ninject.Web.AspNetCore
 {

src/Ninject.Web.AspNetCore/NinjectServiceProvider.cs

@@ -80,37 +80,49 @@ public void Dispose()
 #if NET8_0_OR_GREATER
 		public object GetKeyedService(Type serviceType, object serviceKey)
 		{
+			if (serviceKey == null)
+			{
+				// serviceKey = null means unkeyed
+				return GetService(serviceType);
+			}
+
 			object result;
 			if (!IsListType(serviceType, out var elementType))
 			{
 				EnsureNotAnyKey(serviceKey, serviceType);
 				result = _resolutionRoot.TryGet(serviceType,
-					metadata => metadata.DoesMetadataMatchServiceKey(serviceKey));
+					metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, true));
 			}
 			else
 			{
 				// Ninject is not evaluating metadata constraint when resolving a IEnumerable<T>, see KernelBase.UpdateRequest
 				// Therefore, need to implement a workaround to not instantiate here bindings with a different servicekey value
 				result = ConvertToTypedEnumerable(elementType,
-					_resolutionRoot.GetAll(elementType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey)));
+					_resolutionRoot.GetAll(elementType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, false)));
 			}
 
 			return result;
 		}
 
 		public object GetRequiredKeyedService(Type serviceType, object serviceKey)
 		{
+			if (serviceKey == null)
+			{
+				// serviceKey = null means unkeyed
+				return GetRequiredService(serviceType);
+			}
+
 			if (!IsListType(serviceType, out var elementType))
 			{
 				EnsureNotAnyKey(serviceKey, serviceType);
-				return _resolutionRoot.Get(serviceType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey));
+				return _resolutionRoot.Get(serviceType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, true));
 			}
 			else
 			{
 				// Ninject is not evaluating metadata constraint when resolving a IEnumerable<T>, see KernelBase.UpdateRequest
 				// Therefore, need to implement a workaround to not instantiate here bindings with a different servicekey value
 				return ConvertToTypedEnumerable(elementType,
-					_resolutionRoot.GetAll(elementType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey)).ToList());
+					_resolutionRoot.GetAll(elementType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, false)));
 			}
 		}
 

src/Ninject.Web.AspNetCore/NinjectServiceProviderIsService.cs

@@ -52,7 +52,7 @@ public bool IsKeyedService(Type serviceType, object serviceKey)
 			}
 
 			return _kernel.CanResolve(serviceType, metadata =>
-				metadata.DoesMetadataMatchServiceKey(serviceKey));
+				metadata.DoesMetadataMatchServiceKey(serviceKey, true));
 		}
 #endif
 	}

src/Ninject.Web.AspNetCore/Planning/KeyedServicesMetaDataExtensions.cs

@@ -12,13 +12,18 @@ public static class KeyedServicesMetaDataExtensions
 	{
 
 #if NET8_0_OR_GREATER
-		internal static bool DoesMetadataMatchServiceKey(this IBindingMetadata metadata, object serviceKey)
+		internal static bool DoesMetadataMatchServiceKey(this IBindingMetadata metadata, object serviceKey, bool isUniqueRequest)
 		{
 			if (serviceKey == KeyedService.AnyKey)
 			{
-				return HasServiceKeyMetadata(metadata);
+				// if the service is registered with KeyedService.AnyKey, it must not be returned when querying with AnyKey
+				// see CombinationalRegistration compliancetest
+				return HasServiceKeyMetadata(metadata) && !Object.Equals(metadata.GetServiceKey(), KeyedService.AnyKey);
 			}
-			return Object.Equals(metadata.GetServiceKey(), serviceKey);
+			return Object.Equals(metadata.GetServiceKey(), serviceKey)
+		       // if we query with a key different to KeyedService.AnyKey but registired with AnyKey, we have to return it as well
+		       // see ResolveKeyedServiceSingletonInstanceWithAnyKey compliancetest. But only if we resolve a unique instance
+				|| (isUniqueRequest && Object.Equals(metadata.GetServiceKey(), KeyedService.AnyKey));
 		}
 
 		internal static object GetServiceKey(this IBindingMetadata metadata)

src/Ninject.Web.AspNetCore/Planning/ParameterTargetWithKeyedSupport.cs

@@ -49,7 +49,7 @@ protected override Func<IBindingMetadata, bool> ReadConstraintFromTarget()
 
 				if (metadata.HasServiceKeyMetadata())
 				{
-					result = result && metadata.DoesMetadataMatchServiceKey(keyedattributes[0].Key);
+					result = result && metadata.DoesMetadataMatchServiceKey(keyedattributes[0].Key, true);
 				}
 
 				return result;
@@ -70,7 +70,14 @@ object ITarget.ResolveWithin(IContext parent)
 			var serviceKeyAttributes = GetCustomAttributes(typeof (ServiceKeyAttribute), true) as ServiceKeyAttribute[];
 			if (serviceKeyAttributes?.Length > 0)
 			{
-				return parent.Binding.Metadata.GetServiceKey();
+				var result = parent.Binding.Metadata.GetServiceKey();
+				if (result == KeyedService.AnyKey && this.Type == typeof(string))
+				{
+					// expected to automatically convert from AnyKey to string representation
+					result = KeyedService.AnyKey.ToString();
+				}
+
+				return result;
 			}
 #endif
 			return base.ResolveWithin(parent);