add assembly discovery rules + service registration extensions

zero.Core/Extensions/ServiceCollectionExtensions.cs

@@ -0,0 +1,111 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using zero.Core.Assemblies;
+
+namespace zero.Core.Extensions
+{
+  public static class ServiceCollectionExtensions
+  {
+    public static IAssemblyDiscovery ZeroAssemblyDiscovery { get; set; }
+
+
+    /// <summary>
+    /// Adds all found implementations based on the service type and assembly discovery rules
+    /// </summary>
+    public static void AddAll<TService>(this IServiceCollection services, ServiceLifetime lifetime = ServiceLifetime.Transient) => services.AddAll(typeof(TService), lifetime);
+
+
+    /// <summary>
+    /// Adds all found implementations based on the service type and assembly discovery rules
+    /// </summary>
+    public static void AddAll(this IServiceCollection services, Type serviceType, ServiceLifetime lifetime = ServiceLifetime.Transient)
+    {
+      if (ZeroAssemblyDiscovery == null)
+      {
+        throw new Exception("services.AddAll() can only be run after mvcBuilder.AddZero()");
+      }
+
+      // add implementations with generic service types
+      if (serviceType.GetTypeInfo().IsGenericTypeDefinition)
+      {
+        IEnumerable<(Type, TypeInfo)> matches = ZeroAssemblyDiscovery.GetConcreteTypes().SelectMany(type =>
+        {
+          IEnumerable<Type> genericTypes = type.GetInterfaces().Select(x => x.GetTypeInfo()).Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == serviceType);
+          return genericTypes.Select(x => (x, type));
+        });
+
+        foreach ((Type, Type) match in matches)
+        {
+          services.Add(new ServiceDescriptor(match.Item1, match.Item2, lifetime));
+        }
+      }
+      // add implementations with specific service types
+      else
+      {
+        foreach (Type type in ZeroAssemblyDiscovery.GetTypes(serviceType))
+        {
+          services.Add(new ServiceDescriptor(serviceType, type, lifetime));
+        }
+      }
+    }
+
+
+    /// <summary>
+    /// Adds or overrides an implementation
+    /// </summary>
+    public static void Replace<TService, TImplementation>(this IServiceCollection services) 
+      where TService : class
+      where TImplementation : class, TService
+    {
+      services.Remove<TService>(out ServiceLifetime lifetime);
+      services.Add(new ServiceDescriptor(typeof(TService), typeof(TImplementation), lifetime));
+    }
+
+
+    /// <summary>
+    /// Adds or overrides an implementation
+    /// </summary>
+    public static void Replace<TService, TImplementation>(this IServiceCollection services, Func<IServiceProvider, TImplementation> implementationFactory)
+      where TService : class
+      where TImplementation : class, TService
+    {
+      services.Remove<TService>(out ServiceLifetime lifetime);
+      services.Add(new ServiceDescriptor(typeof(TService), implementationFactory, lifetime));
+    }
+
+
+    /// <summary>
+    /// Removes all instances of a registered service
+    /// </summary>
+    public static bool Remove<TService>(this IServiceCollection services) => services.Remove<TService>(out ServiceLifetime lifetime);
+
+
+    /// <summary>
+    /// Removes all instances of a registered service
+    /// </summary>
+    public static bool Remove<TService>(this IServiceCollection services, out ServiceLifetime lifetime)
+    {
+      Type serviceType = typeof(TService);
+      IEnumerable<ServiceDescriptor> descriptors = services.Where(x => x.ServiceType == serviceType);
+
+      if (descriptors.Any())
+      {
+        lifetime = descriptors.First().Lifetime;
+
+        foreach (ServiceDescriptor descriptor in descriptors)
+        {
+          services.Remove(descriptor);
+        }
+      }
+      else
+      {
+        lifetime = ServiceLifetime.Transient;
+      }
+
+      return descriptors.Any();
+    }
+  }
+}