refactor to remove code duplication in ServiceCollectionAdapter

Author: DominicUllmann

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
+}

src/Ninject.Web.AspNetCore/ServiceCollectionAdapter.cs

@@ -55,23 +55,23 @@ private IBindingWithOrOnSyntax<T> ConfigureImplementationAndLifecycle<T>(
 			ServiceDescriptor descriptor,
 			BindingIndex bindingIndex) where T : class
 		{
-			IBindingNamedWithOrOnSyntax<T> result;
+			IDescriptorAdapter adapter;
 #if NET8_0_OR_GREATER
 			if (descriptor.IsKeyedService)
 			{
-				result = ConfigureImplementationAndLifecycleKeyed(bindingToSyntax, descriptor); 
+				adapter = new KeyedDescriptorAdapter(descriptor);
 			}
 #endif
 #if NET8_0_OR_GREATER
 			else
 			{
 #endif
-				result = ConfigureImplementationAndLifecycleNonKeyed(bindingToSyntax, descriptor);
+				adapter = new DefaultDescriptorAdapter(descriptor);
 #if NET8_0_OR_GREATER
 			}
 #endif
 
-			var resultWithMetadata = result
+			var resultWithMetadata = ConfigureImplementationAndLifecycleWithAdapter(bindingToSyntax, adapter)
 				.WithMetadata(nameof(ServiceDescriptor), descriptor)
 				.WithMetadata(nameof(BindingIndex), bindingIndex.Next(descriptor.ServiceType));
 
@@ -84,15 +84,15 @@ private IBindingWithOrOnSyntax<T> ConfigureImplementationAndLifecycle<T>(
 			return resultWithMetadata;
 		}
 
-		private IBindingNamedWithOrOnSyntax<T> ConfigureImplementationAndLifecycleNonKeyed<T>(IBindingToSyntax<T> bindingToSyntax,
-			ServiceDescriptor descriptor) where T : class
+		private IBindingNamedWithOrOnSyntax<T> ConfigureImplementationAndLifecycleWithAdapter<T>(IBindingToSyntax<T> bindingToSyntax,
+			IDescriptorAdapter adapter) where T : class
 		{
 			IBindingNamedWithOrOnSyntax<T> result;
-			if (descriptor.ImplementationType != null)
+			if (adapter.ImplementationType != null)
 			{
-				result = ConfigureLifecycle(bindingToSyntax.To(descriptor.ImplementationType), descriptor.Lifetime);
+				result = ConfigureLifecycle(bindingToSyntax.To(adapter.ImplementationType), adapter.Lifetime);
 			}
-			else if (descriptor.ImplementationFactory != null)
+			else if (adapter.UseServiceFactory)
 			{
 
 				result = ConfigureLifecycle(bindingToSyntax.ToMethod(context
@@ -102,50 +102,18 @@ private IBindingNamedWithOrOnSyntax<T> ConfigureImplementationAndLifecycleNonKey
 					// correct _scoped_ IServiceProvider is used. Fall back to root IServiceProvider when not created
 					// through a NinjectServiceProvider (some tests do this to prove a point)
 					var scopeProvider = context.GetServiceProviderScopeParameter()?.SourceServiceProvider ?? context.Kernel.Get<IServiceProvider>();
-					return descriptor.ImplementationFactory(scopeProvider) as T;
-				}), descriptor.Lifetime);
+					return adapter.InstantiateFromServiceFactory(scopeProvider) as T;
+				}), adapter.Lifetime);
 			}
 			else
 			{
 				// use ToMethod here as ToConstant has the wrong return type.
-				result = bindingToSyntax.ToMethod(context => descriptor.ImplementationInstance as T).InSingletonScope();
+				result = bindingToSyntax.ToMethod(context => adapter.ImplementationInstance as T).InSingletonScope();
 			}
 
 			return result;
 		}
 
-#if NET8_0_OR_GREATER
-		private IBindingNamedWithOrOnSyntax<T> ConfigureImplementationAndLifecycleKeyed<T>(IBindingToSyntax<T> bindingToSyntax,
-			ServiceDescriptor descriptor) where T : class
-		{
-			IBindingNamedWithOrOnSyntax<T> result;
-			if (descriptor.KeyedImplementationType != null)
-			{
-				result = ConfigureLifecycle(bindingToSyntax.To(descriptor.KeyedImplementationType), descriptor.Lifetime);
-			}
-			else if (descriptor.KeyedImplementationFactory != null)
-			{
-
-				result = ConfigureLifecycle(bindingToSyntax.ToMethod(context
-					=>
-				{
-					// When resolved through the ServiceProviderScopeResolutionRoot which adds this parameter, the
-					// correct _scoped_ IServiceProvider is used. Fall back to root IServiceProvider when not created
-					// through a NinjectServiceProvider (some tests do this to prove a point)
-					var scopeProvider = context.GetServiceProviderScopeParameter()?.SourceServiceProvider ?? context.Kernel.Get<IServiceProvider>();
-					return descriptor.KeyedImplementationFactory(scopeProvider, descriptor.ServiceKey) as T;
-				}), descriptor.Lifetime);
-			}
-			else
-			{
-				// use ToMethod here as ToConstant has the wrong return type.
-				result = bindingToSyntax.ToMethod(context => descriptor.KeyedImplementationInstance as T).InSingletonScope();
-			}
-
-			return result;
-		}
-#endif
-
 		private IBindingNamedWithOrOnSyntax<T> ConfigureLifecycle<T>(
 			IBindingInSyntax<T> bindingInSyntax,
 			ServiceLifetime lifecycleKind)

src/Ninject.Web.AspNetCore/ServiceKey.cs

@@ -5,6 +5,9 @@ namespace Ninject.Web.AspNetCore
 
 #if NET8_0_OR_GREATER
 
+	/// <summary>
+	/// Used to store ServiceDescriptor.ServiceKey as metadata of the Ninject binding.
+	/// </summary>
 	public class ServiceKey
 	{
 		public object Key { get; }