added functionality for registering factories and changing scope.

ffMathy · Jun 12, 2019 · 3cba692 · 3cba692
1 parent ae69ce5
commit 3cba692
Show file tree

Hide file tree

Showing 4 changed files with 94 additions and 22 deletions.
diff --git a/...ependencyInjection.Tests/FluffySpoon.Extensions.MicrosoftDependencyInjection.Tests.csproj b/...ependencyInjection.Tests/FluffySpoon.Extensions.MicrosoftDependencyInjection.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.1.1" />
     <PackageReference Include="MSTest.TestAdapter" Version="1.4.0" />
     <PackageReference Include="MSTest.TestFramework" Version="1.4.0" />
   </ItemGroup>

diff --git a/src/FluffySpoon.Extensions.MicrosoftDependencyInjection.Tests/RegistrationTest.cs b/src/FluffySpoon.Extensions.MicrosoftDependencyInjection.Tests/RegistrationTest.cs
@@ -1,5 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
 
 namespace FluffySpoon.Extensions.MicrosoftDependencyInjection.Tests
 {
@@ -10,7 +11,11 @@ public class RegistrationTest
         public void CanRegisterGenericTypes()
         {
             var services = new ServiceCollection();
-            services.AddAssemblyTypesAsImplementedInterfaces(typeof(RegistrationTest).Assembly);
+            services.AddAssemblyTypesAsImplementedInterfaces(new RegistrationSettings() {
+                Assemblies = new [] {
+                    typeof(RegistrationTest).Assembly
+                }
+            });
 
             var container = services.BuildServiceProvider();
 
@@ -22,12 +27,37 @@ public void CanRegisterGenericTypes()
         public void CanRegisterGenericClassWithNoGenericInterface()
         {
             var services = new ServiceCollection();
-            services.AddAssemblyTypesAsImplementedInterfaces(typeof(RegistrationTest).Assembly);
+            services.AddAssemblyTypesAsImplementedInterfaces(new RegistrationSettings()
+            {
+                Assemblies = new[] {
+                    typeof(RegistrationTest).Assembly
+                }
+            });
 
             var container = services.BuildServiceProvider();
 
             var instance = container.GetService<INonGeneric>();
             Assert.IsNull(instance);
         }
+
+        [TestMethod]
+        public void CanRegisterFactories()
+        {
+            var services = new ServiceCollection();
+
+            var registrationSettings = new RegistrationSettings()
+            {
+                Assemblies = new[] {
+                    typeof(RegistrationTest).Assembly
+                }
+            };
+            services.AddAssemblyTypesAsImplementedInterfaces(registrationSettings);
+            services.AddAssemblyTypesAsFactories(registrationSettings);
+
+            var container = services.BuildServiceProvider();
+
+            var instance = container.GetService<Func<IGenericWrapper>>()();
+            Assert.IsNotNull(instance);
+        }
     }
 }
diff --git a/src/FluffySpoon.Extensions.MicrosoftDependencyInjection/RegistrationExtensions.cs b/src/FluffySpoon.Extensions.MicrosoftDependencyInjection/RegistrationExtensions.cs
@@ -6,10 +6,56 @@
 namespace FluffySpoon.Extensions.MicrosoftDependencyInjection
 {
 	public static class RegistrationExtensions
-	{
-		public static void AddAssemblyTypesAsImplementedInterfaces(
-			this IServiceCollection serviceCollection, 
-			RegistrationSettings settings)
+    {
+        private delegate ServiceDescriptor GetServiceDescriptorDelegate(
+            Type interfaceType, 
+            Type implementationType);
+
+        public static void AddAssemblyTypesAsImplementedInterfaces(
+            this IServiceCollection serviceCollection,
+            RegistrationSettings settings)
+        {
+            AddAssemblyTypesAsImplementedInterfaces(
+                serviceCollection,
+                settings,
+                (interfaceType, implementationType) => 
+                    new ServiceDescriptor(
+                        interfaceType, 
+                        implementationType, 
+                        settings.Scope ?? ServiceLifetime.Scoped));
+        }
+
+        public static void AddAssemblyTypesAsFactories(
+            this IServiceCollection serviceCollection,
+            RegistrationSettings settings)
+        {
+            AddAssemblyTypesAsImplementedInterfaces(
+                serviceCollection,
+                settings,
+                (interfaceType, implementationType) => {
+                    var interfaceFuncType = typeof(Func<>).MakeGenericType(interfaceType);
+                    var serviceProviderExtensionsType = typeof(ServiceProviderServiceExtensions);
+                    var serviceProviderExtensionsGetServiceMethod = serviceProviderExtensionsType
+                        .GetMethods()
+                        .Single(x =>
+                            x.Name == nameof(ServiceProviderServiceExtensions.GetRequiredService) &&
+                            x.IsGenericMethod)
+                        .MakeGenericMethod(interfaceType);
+
+                    return new ServiceDescriptor(
+                        interfaceFuncType,
+                        provider => Delegate.CreateDelegate(
+                            interfaceFuncType,
+                            provider,
+                            serviceProviderExtensionsGetServiceMethod),
+                        settings.Scope ?? ServiceLifetime.Singleton);
+                });
+        }
+
+        private static void AddAssemblyTypesAsImplementedInterfaces(
+			IServiceCollection serviceCollection, 
+			RegistrationSettings settings,
+            GetServiceDescriptorDelegate getServiceDescriptor)
 		{
 			foreach (var assembly in settings.Assemblies)
 			{
@@ -37,9 +83,10 @@ public static class RegistrationExtensions
 							if (implementationType.IsGenericType && interfaceType.IsGenericType)
 							    interfaceType = interfaceType.GetGenericTypeDefinition();
 
-							serviceCollection.AddScoped(
-							    interfaceType, 
-							    implementationType);
+                            var descriptor = getServiceDescriptor(
+                                interfaceType, 
+                                implementationType);
+                            serviceCollection.Add(descriptor);
 						}
 					} catch(Exception ex) {
 						throw new Exception("Could not load type " + classType.FullName, ex);
@@ -56,14 +103,5 @@ public static class RegistrationExtensions
 				(type.Namespace != null && 
 				settings.Filter(type));
 		}
-
-		public static void AddAssemblyTypesAsImplementedInterfaces(
-			this IServiceCollection serviceCollection, 
-			params Assembly[] assemblies)
-		{
-			AddAssemblyTypesAsImplementedInterfaces(serviceCollection, new RegistrationSettings() {
-				Assemblies = assemblies
-			});
-		}
 	}
 }
diff --git a/src/FluffySpoon.Extensions.MicrosoftDependencyInjection/RegistrationSettings.cs b/src/FluffySpoon.Extensions.MicrosoftDependencyInjection/RegistrationSettings.cs
@@ -1,4 +1,5 @@
-using System;
+using Microsoft.Extensions.DependencyInjection;
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Text;
@@ -9,11 +10,14 @@ public class RegistrationSettings
 	{
 		public Func<Type, bool> Filter { get; set; }
 
-		public IEnumerable<Assembly> Assemblies { get; set; }
+        public ServiceLifetime? Scope { get; set; }
+
+        public IEnumerable<Assembly> Assemblies { get; set; }
 
 		public RegistrationSettings()
 		{
 			Assemblies = new List<Assembly>();
-		}
+            Scope = ServiceLifetime.Scoped;
+        }
 	}
 }