fix binding overriding with keyed services

Author: DominicUllmann

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

@@ -86,7 +86,7 @@ public DummyBinding()
 
 			public DummyBinding WithIndex(BindingIndex index)
 			{
-				Metadata.Set(nameof(BindingIndex), index.Next(Service));
+				Metadata.Set(nameof(BindingIndex), index.Next(Service, BindingIndex.DefaultIndexKey));
 				return this;
 			}
 

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

@@ -203,7 +203,7 @@ public void ExistingMultipleServices_ResolvesNonKeyedToException()
 			var provider = CreateServiceProvider(kernel);
 
 			Action action = () => provider.GetRequiredService(typeof(IWarrior));
-			action.Should().Throw<ActivationException>().WithMessage("*More than one matching bindings are available*");
+			action.Should().Throw<ActivationException>().WithMessage("*No matching bindings are available, and the type is not self-bindable.*");
 		}
 
 		private IServiceProvider CreateServiceProvider(AspNetCoreKernel kernel)

src/Ninject.Web.AspNetCore/AspNetCoreKernel.cs

@@ -36,6 +36,9 @@ protected override Func<IBinding, bool> SatifiesRequest(IRequest request)
 				var latest = true;
 				if (request.IsUnique)
 				{
+					// as we can't register constraints via microsoft.extensions.dependencyinjection, 
+					// we always check for the latest binding
+					// Note that we have at least one constraint for the servicekey >= .NET 8.0
 					latest = binding.Metadata.Get<BindingIndex.Item>(nameof(BindingIndex))?.IsLatest ?? true;
 				}
 				return binding.Matches(request) && request.Matches(binding) && latest;

src/Ninject.Web.AspNetCore/BindingIndex.cs

@@ -5,28 +5,29 @@ namespace Ninject.Web.AspNetCore
 {
 	public class BindingIndex
 	{
-		private readonly IDictionary<Type, Item> _bindingIndexMap = new Dictionary<Type, Item>();
+		private readonly IDictionary<ServiceTypeKey, Item> _bindingIndexMap = new Dictionary<ServiceTypeKey, Item>();
+		public const string DefaultIndexKey = "NonKeyed";
 
 		public int Count { get; private set; }
 
 		public BindingIndex()
 		{
 		}
 
-		public Item Next(Type serviceType)
+		public Item Next(Type serviceType, object indexKey)
 		{
-			
-			_bindingIndexMap.TryGetValue(serviceType, out var previous);
+			var serviceTypeKey = new ServiceTypeKey(serviceType, indexKey);
+			_bindingIndexMap.TryGetValue(serviceTypeKey, out var previous);
 
-			var next = new Item(this, serviceType, Count++, previous?.TypeIndex + 1 ?? 0);
-			_bindingIndexMap[serviceType] = next;
+			var next = new Item(this, serviceType, indexKey, Count++, previous?.TypeIndex + 1 ?? 0);
+			_bindingIndexMap[serviceTypeKey] = next;
 
 			return next;
 		}
 
-		private bool IsLatest(Type serviceType, Item item)
+		private bool IsLatest(Type serviceType, object indexKey, Item item)
 		{
-			return _bindingIndexMap[serviceType] == item;
+			return _bindingIndexMap[new ServiceTypeKey(serviceType, indexKey)] == item;
 		}
 
 		public class Item
@@ -36,16 +37,55 @@ public class Item
 
 			public int TotalIndex { get; }
 			public int TypeIndex { get; }
+			public object IndexKey { get; }
 
-			public bool IsLatest => _root.IsLatest(_serviceType, this);
+			public bool IsLatest => _root.IsLatest(_serviceType, IndexKey, this);
 			public int Precedence => _root.Count - TotalIndex;
 
-			public Item(BindingIndex root, Type serviceType, int totalIndex, int typeIndex)
+			public Item(BindingIndex root, Type serviceType, object indexKey, int totalIndex, int typeIndex)
 			{
 				_root = root;
 				_serviceType = serviceType;
 				TotalIndex = totalIndex;
 				TypeIndex = typeIndex;
+				IndexKey = indexKey;
+			}
+		}
+
+		/// <summary>
+		/// We have to to separate the precedence by servicekey.
+		/// This ensures that a binding with a different servicekey
+		/// can't override a binding with a non-matching servicekey
+		/// </summary>
+		public class ServiceTypeKey : IEquatable<ServiceTypeKey>
+		{
+			public Type ServiceType { get; }
+			public object IndexKey { get; }
+
+			public ServiceTypeKey(Type serviceType, object indexKey)
+			{
+				ServiceType = serviceType;
+				IndexKey = indexKey;
+			}
+
+			public bool Equals(ServiceTypeKey other)
+			{
+				if (other is null) return false;
+				if (ReferenceEquals(this, other)) return true;
+				return Equals(ServiceType, other.ServiceType) && Equals(IndexKey, other.IndexKey);
+			}
+
+			public override bool Equals(object obj)
+			{
+				if (obj is null) return false;
+				if (ReferenceEquals(this, obj)) return true;
+				if (obj.GetType() != GetType()) return false;
+				return Equals((ServiceTypeKey)obj);
+			}
+
+			public override int GetHashCode()
+			{
+				return HashCode.Combine(ServiceType, IndexKey);
 			}
 		}
 	}

…torReflectionStrategyWithKeyedSupport.cs …torReflectionStrategyWithKeyedSupport.cssrc/Ninject.Web.AspNetCore/Planning/ConstructorReflectionStrategyWithKeyedSupport.cs renamed to src/Ninject.Web.AspNetCore/Components/ConstructorReflectionStrategyWithKeyedSupport.cs src/Ninject.Web.AspNetCore/Planning/ConstructorReflectionStrategyWithKeyedSupport.cs renamed to src/Ninject.Web.AspNetCore/Components/ConstructorReflectionStrategyWithKeyedSupport.cs

@@ -7,8 +7,9 @@
 using Ninject.Planning.Directives;
 using Ninject.Planning.Strategies;
 using Ninject.Selection;
+using Ninject.Web.AspNetCore.Planning;
 
-namespace Ninject.Web.AspNetCore.Planning
+namespace Ninject.Web.AspNetCore.Components
 {
 	/// <summary>
 	/// Adds a directive to plans indicating which constructor should be injected during activation.

src/Ninject.Web.AspNetCore/ServiceCollectionAdapter.cs

@@ -72,15 +72,17 @@ private IBindingWithOrOnSyntax<T> ConfigureImplementationAndLifecycle<T>(
 #endif
 
 			var resultWithMetadata = ConfigureImplementationAndLifecycleWithAdapter(bindingToSyntax, adapter)
-				.WithMetadata(nameof(ServiceDescriptor), descriptor)
-				.WithMetadata(nameof(BindingIndex), bindingIndex.Next(descriptor.ServiceType));
+				.WithMetadata(nameof(ServiceDescriptor), descriptor);
 
+			object indexKey = BindingIndex.DefaultIndexKey;
 #if NET8_0_OR_GREATER
 			if (descriptor.IsKeyedService)
 			{
 				resultWithMetadata = resultWithMetadata.WithMetadata(nameof(ServiceKey), new ServiceKey(descriptor.ServiceKey));
+				indexKey = descriptor.ServiceKey;
 			}
 #endif
+			resultWithMetadata = resultWithMetadata.WithMetadata(nameof(BindingIndex), bindingIndex.Next(descriptor.ServiceType, indexKey));
 			return resultWithMetadata;
 		}