refactor to support dynamic binding of services registred with anykey, but resolved with a specific key by using a missing binding resolver

Author: DominicUllmann

src/Ninject.Web.AspNetCore/AspNetCoreKernel.cs

@@ -50,7 +50,7 @@ protected override Func<IBinding, bool> SatifiesRequest(IRequest request)
 						requestIndexKey = serviceKeyParameter.ServiceKey;
 					}
 #endif
-					latest = binding.Metadata.Get<BindingIndex.Item>(nameof(BindingIndex))?.IsLatest(requestIndexKey) ?? true;
+					latest = binding.Metadata.Get<BindingIndex.Item>(nameof(BindingIndex))?.IsLatest ?? true;
 				}
 				return binding.Matches(request) && request.Matches(binding) && latest;
 			};
@@ -71,6 +71,10 @@ protected override void AddComponents()
 			Components.Add<IDisposalManager, DisposalManager>();
 			Components.Remove<IActivationStrategy, DisposableStrategy>();
 			Components.Add<IActivationStrategy, OrderedDisposalStrategy>();
+
+#if NET8_0_OR_GREATER
+			Components.Add<IMissingBindingResolver, AnyBindingResolver>();
+#endif
 		}
 
 		public void DisableAutomaticSelfBinding()

src/Ninject.Web.AspNetCore/BindingIndex.cs

@@ -26,17 +26,9 @@ public Item Next(Type serviceType, object indexKey)
 			return next;
 		}
 
-		private bool IsLatest(Type serviceType, object registeredIndexKey, object requestIndexKey, Item item)
+		private bool IsLatest(Type serviceType, object registeredIndexKey, Item item)
 		{
 			var match = _bindingIndexMap[new ServiceTypeKey(serviceType, registeredIndexKey)] == item;
-#if NET8_0_OR_GREATER
-			if (registeredIndexKey == KeyedService.AnyKey)
-			{
-				// if the binding is registered with anykey, it should only be considered as latest if there is no
-				// exact match with the requestIndexKey
-				match = !_bindingIndexMap.TryGetValue(new ServiceTypeKey(serviceType, requestIndexKey), out _);
-			}
-#endif
 			return match;
 		}
 
@@ -60,7 +52,7 @@ public Item(BindingIndex root, Type serviceType, object indexKey, int totalIndex
 				IndexKey = indexKey;
 			}
 
-			public bool IsLatest(object requestIndexKey) => _root.IsLatest(_serviceType, IndexKey, requestIndexKey, this);
+			public bool IsLatest => _root.IsLatest(_serviceType, IndexKey, this);
 		}
 
 		/// <summary>

src/Ninject.Web.AspNetCore/NinjectServiceProvider.cs

@@ -9,6 +9,7 @@
 using Ninject.Planning.Bindings;
 using Ninject.Web.AspNetCore.Parameters;
 using Ninject.Web.AspNetCore.Planning;
+using Ninject.Web.AspNetCore.RequestActivation;
 
 namespace Ninject.Web.AspNetCore
 {
@@ -92,17 +93,14 @@ public object GetKeyedService(Type serviceType, object serviceKey)
 			if (!IsListType(serviceType, out var elementType))
 			{
 				EnsureNotAnyKey(serviceKey, serviceType);
-				result = _resolutionRoot.TryGet(serviceType,
-					metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, true),
-					new ServiceKeyParameter(serviceKey));
+				return ResolveKeyedService<object>(serviceType, serviceKey, true, 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, false),
-						new ServiceKeyParameter(serviceKey)));
+					ResolveKeyedService<IEnumerable<object>>(elementType, serviceKey, false, true));
 			}
 
 			return result;
@@ -119,16 +117,29 @@ public object GetRequiredKeyedService(Type serviceType, object serviceKey)
 			if (!IsListType(serviceType, out var elementType))
 			{
 				EnsureNotAnyKey(serviceKey, serviceType);
-				return _resolutionRoot.Get(serviceType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey, true),
-					new ServiceKeyParameter(serviceKey));
+				return ResolveKeyedService<object>(serviceType, serviceKey, true, false);
 			}
 			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, false),
-						new ServiceKeyParameter(serviceKey)));
+					ResolveKeyedService<IEnumerable<object>>(elementType, serviceKey, false, true));
+			}
+		}
+
+		private T ResolveKeyedService<T>(Type serviceType, object serviceKey, bool isUnique, bool isOptional) where T : class
+		{
+			var standardRequest = _resolutionRoot.CreateRequest(serviceType, metadata => metadata.DoesMetadataMatchServiceKey(serviceKey), Array.Empty<Parameter>(), isOptional, isUnique);
+			var keyedRequest = standardRequest.ToKeyedRequest(serviceKey);
+			var result = _resolutionRoot.Resolve(keyedRequest);
+			if (isUnique)
+			{
+				return (result as object[]).FirstOrDefault() as T;
+			}
+			else
+			{
+				return result as T;
 			}
 		}
 
@@ -180,6 +191,7 @@ private static object ConvertToTypedEnumerable(Type elementType, IEnumerable<obj
 		{
 			var castMethod = EnumerableCastMethod.MakeGenericMethod(elementType);
 			var result = (IEnumerable)castMethod.Invoke(null, new object[] { objectList });
+
 			return result;
 		}
 

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, true));
+				metadata.DoesMetadataMatchServiceKey(serviceKey));
 		}
 #endif
 	}

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

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Ninject.Activation;
+using Ninject.Activation.Providers;
+using Ninject.Components;
+using Ninject.Infrastructure;
+using Ninject.Planning.Bindings;
+using Ninject.Planning.Bindings.Resolvers;
+using Ninject.Web.AspNetCore.RequestActivation;
+
+namespace Ninject.Web.AspNetCore.Planning
+{
+#if NET8_0_OR_GREATER	
+	public class AnyBindingResolver : NinjectComponent, IMissingBindingResolver
+	{
+		public IEnumerable<IBinding> Resolve(Multimap<Type, IBinding> bindings, IRequest request)
+		{
+			// we resolve here request with a specific service key, but only having a binding with anykey.
+			// this ensures that we e.g. can have a singleton binding with anykey, but instantiate one singleton
+			// per servicekey.
+			var keyedRequest = request as KeyedRequest;
+			if (keyedRequest != null && keyedRequest.ServiceKey != null &&  keyedRequest.ServiceKey != KeyedService.AnyKey 
+			    && keyedRequest.IsUnique)
+			{
+				var service = request.Service;
+				var matchingBindings = bindings.Where(x => x.Key == service);
+				if (!matchingBindings.Any())
+				{
+					return Array.Empty<IBinding>();
+				}
+
+				IBinding matchingAnyBinding = null;
+				foreach (var bindingGroup in matchingBindings)
+				{
+					foreach (var binding in bindingGroup.Value)
+					{
+						if (binding.Metadata.HasServiceKeyMetadata() && Object.Equals(binding.Metadata.GetServiceKey(), KeyedService.AnyKey)
+						    && (binding.Metadata.Get<BindingIndex.Item>(nameof(BindingIndex))?.IsLatest ?? true)
+						    )
+						{
+							matchingAnyBinding = binding;
+							break;
+						}
+					}
+				}
+
+				if (matchingAnyBinding == null)
+				{
+					return Array.Empty<IBinding>();
+				}
+
+				var resultBinding = new Binding(service)
+				{
+					IsImplicit = true,
+					ProviderCallback = matchingAnyBinding.ProviderCallback,
+					ScopeCallback = matchingAnyBinding.ScopeCallback,
+					Target = matchingAnyBinding.Target
+				};
+				var bindingIndex = new BindingIndex();
+				resultBinding.Metadata.Set(nameof(BindingIndex), bindingIndex.Next(service, keyedRequest.ServiceKey));
+				resultBinding.Metadata.Set(nameof(ServiceKey), new ServiceKey(keyedRequest.ServiceKey));
+				resultBinding.Metadata.Set(nameof(ServiceDescriptor), matchingAnyBinding.Metadata.Get<IDescriptorAdapter>(nameof(ServiceDescriptor)));
+
+				return new Binding[1]
+				{
+					resultBinding
+				};
+			}
+
+			return Array.Empty<IBinding>();
+		}
+	}
+#endif
+}

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

@@ -12,18 +12,19 @@ public static class KeyedServicesMetaDataExtensions
 	{
 
 #if NET8_0_OR_GREATER
-		internal static bool DoesMetadataMatchServiceKey(this IBindingMetadata metadata, object serviceKey, bool isUniqueRequest)
+		internal static bool DoesMetadataMatchServiceKey(this IBindingMetadata metadata, object serviceKey)
 		{
 			if (serviceKey == KeyedService.AnyKey)
 			{
 				// 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)
-		       // 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));
+
+			return Object.Equals(metadata.GetServiceKey(), serviceKey);
+			// if we query with a key different to KeyedService.AnyKey but registired with AnyKey, we have to instantiate it in the end
+			// but we do this with a missingbinding resolver, the AnyBindingResolver. But only if we resolve a unique instance
+			// see ResolveKeyedServiceSingletonInstanceWithAnyKey compliancetest. 
 		}
 
 		internal static object GetServiceKey(this IBindingMetadata metadata)

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

@@ -6,6 +6,7 @@
 using Ninject.Planning.Bindings;
 using Ninject.Planning.Targets;
 using Ninject.Web.AspNetCore.Parameters;
+using Ninject.Web.AspNetCore.RequestActivation;
 
 namespace Ninject.Web.AspNetCore.Planning
 {
@@ -55,7 +56,13 @@ protected override Func<IBindingMetadata, bool> ReadConstraintFromTarget()
 
 				if (metadata.HasServiceKeyMetadata())
 				{
-					result = result && metadata.DoesMetadataMatchServiceKey(keyedattributes[0].Key, true);
+					object keyToCompareWith = keyedattributes[0].Key;
+#if NET10_0_OR_GREATER
+					if (keyedattributes[0].LookupMode == ServiceKeyLookupMode.InheritKey) {
+						// here we would need the request!
+					}
+#endif
+					result = result && metadata.DoesMetadataMatchServiceKey(keyToCompareWith);
 				}
 				else
 				{
@@ -111,6 +118,14 @@ object ITarget.ResolveWithin(IContext parent)
 
 				return result;
 			}
+
+			var keyedattributes = GetCustomAttributes(typeof (FromKeyedServicesAttribute), true) as FromKeyedServicesAttribute[];
+			if (keyedattributes?.Length > 0)
+			{
+				var child = parent.Request.CreateKeyedChildRequest(Type, keyedattributes[0].Key, parent, this);
+				child.IsUnique = true;
+				return parent.Kernel.Resolve(child).SingleOrDefault();
+			}
 #endif
 			return base.ResolveWithin(parent);
 		}