feat: append to existing services (Snowberry.DependencyInjection)

Author: VNNCC

src/NuGetPackage.props

@@ -4,7 +4,7 @@
         <Platforms>AnyCPU;x64;x86</Platforms>
 
         <Authors>Snowberry Software</Authors>
-        <AssemblyVersion>1.0.0.0</AssemblyVersion>
+        <AssemblyVersion>1.0.1.0</AssemblyVersion>
         <VersionPrefix>$(AssemblyVersion)</VersionPrefix>
         <VersionSuffix>alpha</VersionSuffix>
 

src/Snowberry.Mediator.DependencyInjection.Shared/Contracts/IServiceContext.cs

@@ -0,0 +1,37 @@
+namespace Snowberry.Mediator.DependencyInjection.Shared.Contracts;
+
+/// <summary>
+/// Defines a context for registering services with specific lifetimes.
+/// </summary>
+public interface IServiceContext
+{
+    /// <summary>
+    /// Tries to get a singleton instance of the service type <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The service type.</typeparam>
+    /// <param name="found">Indicates whether the singleton was found.</param>
+    /// <returns>The singleton.</returns>
+    T? TryToGetSingleton<T>(out bool found);
+
+    /// <summary>
+    /// Checks if the service type <typeparamref name="T"/> is already registered.
+    /// </summary>
+    /// <typeparam name="T">The service type.</typeparam>
+    /// <returns>The result.</returns>
+    bool IsServiceRegistered<T>();
+
+    /// <summary>
+    /// Registers a service with the specified lifetime.
+    /// </summary>
+    /// <param name="serviceType">The service type.</param>
+    /// <param name="implementationType">The implementation type.</param>
+    /// <param name="lifetime">The service lifetime.</param>
+    void Register(Type serviceType, Type implementationType, RegistrationServiceLifetime lifetime);
+
+    /// <summary>
+    /// Registers a singleton instance of a service.
+    /// </summary>
+    /// <param name="serviceType">The service type.</param>
+    /// <param name="instance">The instance type.</param>
+    void Register(Type serviceType, object instance);
+}

src/Snowberry.Mediator.DependencyInjection.Shared/DependencyInjectionHelper.cs

@@ -1,64 +1,89 @@
 using Snowberry.Mediator.Abstractions;
+using Snowberry.Mediator.Abstractions.Handler;
 using Snowberry.Mediator.Abstractions.Pipeline;
+using Snowberry.Mediator.DependencyInjection.Shared.Contracts;
 using Snowberry.Mediator.Extensions;
 using Snowberry.Mediator.Models;
 using Snowberry.Mediator.Registries;
 using Snowberry.Mediator.Registries.Contracts;
 
 namespace Snowberry.Mediator.DependencyInjection.Shared;
 
+/// <summary>
+/// Helper type for adding Mediator services to a service context.
+/// </summary>
 public static class DependencyInjectionHelper
 {
-    public static void AddSnowberryMediator(IServiceContext serviceContext, MediatorOptions options, RegistrationServiceLifetime serviceLifetime)
+    /// <summary>
+    /// Adds Mediator services to the specified service context.
+    /// </summary>
+    /// <param name="serviceContext">The service context.</param>
+    /// <param name="options">The options.</param>
+    /// <param name="serviceLifetime">The service lifetime.</param>
+    /// <param name="append">Whether to append to existing registrations or replace them.</param>
+    public static void AddSnowberryMediator(
+        IServiceContext serviceContext,
+        MediatorOptions options,
+        RegistrationServiceLifetime serviceLifetime,
+        bool append)
     {
-        serviceContext.Register(typeof(IMediator), typeof(Mediator), serviceLifetime);
-
-        if (options.Assemblies == null || options.Assemblies.Count == 0)
-            return;
+        if (!append || !serviceContext.IsServiceRegistered<IMediator>())
+            serviceContext.Register(typeof(IMediator), typeof(Mediator), serviceLifetime);
 
         var allHandlers = new List<RequestHandlerInfo>();
         var allStreamHandlers = new List<StreamRequestHandlerInfo>();
         var allPipelineBehaviorHandlers = new List<PipelineBehaviorHandlerInfo>();
         var allStreamPipelineBehaviorHandlers = new List<StreamPipelineBehaviorHandlerInfo>();
         var allNotificationHandlers = new List<NotificationHandlerInfo>();
 
-        for (int i = 0; i < options.Assemblies.Count; i++)
+        if (options.Assemblies != null && options.Assemblies.Count > 0)
         {
-            var assembly = options.Assemblies[i];
+            for (int i = 0; i < options.Assemblies.Count; i++)
+            {
+                var assembly = options.Assemblies[i];
 
-            var scanResult = MediatorAssemblyHelper.ScanAssembly(assembly);
+                var scanResult = MediatorAssemblyHelper.ScanAssembly(assembly);
 
-            if (scanResult.RequestHandlerTypes != null)
-                for (int j = 0; j < scanResult.RequestHandlerTypes.Count; j++)
-                    allHandlers.Add(scanResult.RequestHandlerTypes[j]);
+                if (scanResult.RequestHandlerTypes != null)
+                    for (int j = 0; j < scanResult.RequestHandlerTypes.Count; j++)
+                        allHandlers.Add(scanResult.RequestHandlerTypes[j]);
 
-            if (scanResult.StreamRequestHandlerTypes != null)
-                for (int j = 0; j < scanResult.StreamRequestHandlerTypes.Count; j++)
-                    allStreamHandlers.Add(scanResult.StreamRequestHandlerTypes[j]);
+                if (scanResult.StreamRequestHandlerTypes != null)
+                    for (int j = 0; j < scanResult.StreamRequestHandlerTypes.Count; j++)
+                        allStreamHandlers.Add(scanResult.StreamRequestHandlerTypes[j]);
 
-            if (options.RegisterPipelineBehaviors && options.ScanPipelineBehaviors && scanResult.PipelineBehaviorTypes != null)
-                for (int j = 0; j < scanResult.PipelineBehaviorTypes.Count; j++)
-                    allPipelineBehaviorHandlers.Add(scanResult.PipelineBehaviorTypes[j]);
+                if (options.RegisterPipelineBehaviors && options.ScanPipelineBehaviors && scanResult.PipelineBehaviorTypes != null)
+                    for (int j = 0; j < scanResult.PipelineBehaviorTypes.Count; j++)
+                        allPipelineBehaviorHandlers.Add(scanResult.PipelineBehaviorTypes[j]);
 
-            if (options.RegisterStreamPipelineBehaviors && options.ScanStreamPipelineBehaviors && scanResult.StreamPipelineBehaviorTypes != null)
-                for (int j = 0; j < scanResult.StreamPipelineBehaviorTypes.Count; j++)
-                    allStreamPipelineBehaviorHandlers.Add(scanResult.StreamPipelineBehaviorTypes[j]);
+                if (options.RegisterStreamPipelineBehaviors && options.ScanStreamPipelineBehaviors && scanResult.StreamPipelineBehaviorTypes != null)
+                    for (int j = 0; j < scanResult.StreamPipelineBehaviorTypes.Count; j++)
+                        allStreamPipelineBehaviorHandlers.Add(scanResult.StreamPipelineBehaviorTypes[j]);
 
-            if (options.RegisterNotificationHandlers && options.ScanNotificationHandlers && scanResult.NotificationHandlerTypes != null)
-                for (int j = 0; j < scanResult.NotificationHandlerTypes.Count; j++)
-                    allNotificationHandlers.Add(scanResult.NotificationHandlerTypes[j]);
+                if (options.RegisterNotificationHandlers && options.ScanNotificationHandlers && scanResult.NotificationHandlerTypes != null)
+                    for (int j = 0; j < scanResult.NotificationHandlerTypes.Count; j++)
+                        allNotificationHandlers.Add(scanResult.NotificationHandlerTypes[j]);
+            }
         }
 
         var pipelineBehaviorType = typeof(IPipelineBehavior<,>);
         var streamPipelineBehaviorType = typeof(IStreamPipelineBehavior<,>);
+        var requestHandlerType = typeof(IRequestHandler<,>);
+        var streamRequestHandlerType = typeof(IStreamRequestHandler<,>);
+
+        if (options.PipelineBehaviorTypes != null && options.RegisterPipelineBehaviors)
+            MediatorAssemblyHelper.ParseHandlerInfo(pipelineBehaviorType, options.PipelineBehaviorTypes, allPipelineBehaviorHandlers);
+
+        if (options.RequestHandlerTypes != null && options.RegisterRequestHandlers)
+            MediatorAssemblyHelper.ParseHandlerInfo(requestHandlerType, options.RequestHandlerTypes, allHandlers);
 
-        if (options.PipelineBehaviorTypes != null)
-            MediatorAssemblyHelper.ParsePipelineBehaviors(pipelineBehaviorType, options.PipelineBehaviorTypes, allPipelineBehaviorHandlers);
+        if (options.StreamRequestHandlerTypes != null && options.RegisterStreamRequestHandlers)
+            MediatorAssemblyHelper.ParseHandlerInfo(streamRequestHandlerType, options.StreamRequestHandlerTypes, allStreamHandlers);
 
-        if (options.StreamPipelineBehaviorTypes != null)
-            MediatorAssemblyHelper.ParsePipelineBehaviors(streamPipelineBehaviorType, options.StreamPipelineBehaviorTypes, allStreamPipelineBehaviorHandlers);
+        if (options.StreamPipelineBehaviorTypes != null && options.RegisterStreamPipelineBehaviors)
+            MediatorAssemblyHelper.ParseHandlerInfo(streamPipelineBehaviorType, options.StreamPipelineBehaviorTypes, allStreamPipelineBehaviorHandlers);
 
-        if (options.NotificationHandlerTypes != null)
+        if (options.NotificationHandlerTypes != null && options.RegisterNotificationHandlers)
             MediatorAssemblyHelper.ParseNotificationHandlers(options.NotificationHandlerTypes, allNotificationHandlers);
 
         for (int i = 0; i < allHandlers.Count; i++)
@@ -77,49 +102,91 @@ public static void AddSnowberryMediator(IServiceContext serviceContext, Mediator
             AddPipelineBehaviors<IGlobalPipelineRegistry, GlobalPipelineRegistry, PipelineBehaviorHandlerInfo>(
                 serviceContext,
                 serviceLifetime,
-                allPipelineBehaviorHandlers);
+                allPipelineBehaviorHandlers,
+                append);
 
         if (options.RegisterStreamPipelineBehaviors && allStreamPipelineBehaviorHandlers.Count > 0)
             AddPipelineBehaviors<IGlobalStreamPipelineRegistry, GlobalStreamPipelineRegistry, StreamPipelineBehaviorHandlerInfo>(
                 serviceContext,
                 serviceLifetime,
-                allStreamPipelineBehaviorHandlers);
+                allStreamPipelineBehaviorHandlers,
+                append);
 
         if (options.RegisterNotificationHandlers && allNotificationHandlers.Count > 0)
-            AddNotificationHandlers(serviceContext, serviceLifetime, allNotificationHandlers);
+            AddNotificationHandlers(serviceContext, serviceLifetime, allNotificationHandlers, append);
     }
 
-    private static void AddPipelineBehaviors<TGlobalPipelineInterface, TGlobalPipelineRegistry, THandlerInfo>(IServiceContext serviceContext, RegistrationServiceLifetime serviceLifetime, IList<THandlerInfo> pipelineBehaviorHandlers)
-        where TGlobalPipelineRegistry : IBaseGlobalPipelineRegistry<THandlerInfo>, new()
+    private static void AddPipelineBehaviors<TGlobalPipelineInterface, TGlobalPipelineRegistry, THandlerInfo>(
+        IServiceContext serviceContext,
+        RegistrationServiceLifetime serviceLifetime,
+        IList<THandlerInfo> pipelineBehaviorHandlers,
+        bool append
+    )
+        where TGlobalPipelineRegistry : TGlobalPipelineInterface, new()
+        where TGlobalPipelineInterface : IBaseGlobalPipelineRegistry<THandlerInfo>
         where THandlerInfo : PipelineBehaviorHandlerInfo
     {
         if (pipelineBehaviorHandlers.Count == 0)
             return;
 
-        var globalPipelineRegistry = new TGlobalPipelineRegistry();
-        serviceContext.Register(serviceType: typeof(TGlobalPipelineInterface), instance: globalPipelineRegistry);
+        TGlobalPipelineInterface? globalPipelineRegistry = default;
+        if (!append || !serviceContext.IsServiceRegistered<TGlobalPipelineInterface>())
+        {
+            globalPipelineRegistry = new TGlobalPipelineRegistry();
+            serviceContext.Register(serviceType: typeof(TGlobalPipelineInterface), instance: globalPipelineRegistry);
+        }
+        else
+        {
+            globalPipelineRegistry = serviceContext.TryToGetSingleton<TGlobalPipelineInterface>(out bool foundSingleton);
+
+            if (!foundSingleton)
+            {
+                globalPipelineRegistry = new TGlobalPipelineRegistry();
+                serviceContext.Register(serviceType: typeof(TGlobalPipelineInterface), instance: globalPipelineRegistry);
+            }
+        }
 
         for (int i = 0; i < pipelineBehaviorHandlers.Count; i++)
         {
             var handler = pipelineBehaviorHandlers[i];
-            globalPipelineRegistry.Register(handler);
+            globalPipelineRegistry!.Register(handler);
 
             serviceContext.Register(handler.HandlerType, handler.HandlerType, serviceLifetime);
         }
     }
 
-    private static void AddNotificationHandlers(IServiceContext serviceContext, RegistrationServiceLifetime serviceLifetime, IList<NotificationHandlerInfo> notificationHandlers)
+    private static void AddNotificationHandlers(
+        IServiceContext serviceContext,
+        RegistrationServiceLifetime serviceLifetime,
+        IList<NotificationHandlerInfo> notificationHandlers,
+        bool append
+    )
     {
         if (notificationHandlers.Count == 0)
             return;
 
-        var globalNotificationHandlerRegistry = new GlobalNotificationHandlerRegistry();
-        serviceContext.Register(serviceType: typeof(IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>), instance: globalNotificationHandlerRegistry);
+        IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>? globalNotificationHandlerRegistry = null;
+
+        if (!append || !serviceContext.IsServiceRegistered<IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>>())
+        {
+            globalNotificationHandlerRegistry = new GlobalNotificationHandlerRegistry();
+            serviceContext.Register(serviceType: typeof(IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>), instance: globalNotificationHandlerRegistry);
+        }
+        else
+        {
+            globalNotificationHandlerRegistry = serviceContext.TryToGetSingleton<IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>>(out bool foundSingleton);
+
+            if (!foundSingleton)
+            {
+                globalNotificationHandlerRegistry = new GlobalNotificationHandlerRegistry();
+                serviceContext.Register(serviceType: typeof(IGlobalNotificationHandlerRegistry<NotificationHandlerInfo>), instance: globalNotificationHandlerRegistry);
+            }
+        }
 
         for (int i = 0; i < notificationHandlers.Count; i++)
         {
             var handler = notificationHandlers[i];
-            globalNotificationHandlerRegistry.Register(handler);
+            globalNotificationHandlerRegistry!.Register(handler);
 
             serviceContext.Register(handler.HandlerType, handler.HandlerType, serviceLifetime);
         }

src/Snowberry.Mediator.DependencyInjection.Shared/IServiceContext.cs

@@ -1,8 +1,22 @@
 namespace Snowberry.Mediator.DependencyInjection.Shared;
 
+/// <summary>
+/// The lifetime of a service.
+/// </summary>
 public enum RegistrationServiceLifetime
 {
+    /// <summary>
+    /// A single instance is created and shared throughout the application's lifetime.
+    /// </summary>
     Singleton,
+
+    /// <summary>
+    /// A new instance is created each time the service is requested.
+    /// </summary>
     Transient,
+
+    /// <summary>
+    /// A new instance is created for each scope.
+    /// </summary>
     Scoped
 }

src/Snowberry.Mediator.DependencyInjection.Shared/RegistrationServiceLifetime.cs

@@ -12,11 +12,48 @@ public static class ServiceCollectionExtensions
     /// <summary>
     /// Adds the Mediator services to the specified <see cref="IServiceRegistry" />.
     /// </summary>
+    /// <remarks>
+    /// A service provider must be registered in the service collection before calling this method.
+    /// Alternatively, if the <see cref="IServiceRegistry"/> instance is also an <see cref="IServiceProvider"/>, it will be registered as a singleton.
+    /// </remarks>
     /// <param name="serviceRegistry">The service collection.</param>
     /// <param name="configure">The configuration method.</param>
     /// <param name="serviceLifetime">The service lifetime of the mediator and handlers.</param>
     /// <returns>The service collection.</returns>
     public static IServiceRegistry AddSnowberryMediator(this IServiceRegistry serviceRegistry, Action<MediatorOptions> configure, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
+    {
+        return AddSnowberryMediator(serviceRegistry, configure, serviceLifetime, append: false);
+    }
+
+    /// <summary>
+    /// Appends the Mediator services to the specified <see cref="IServiceRegistry" /> and preserves existing registrations.
+    /// </summary>
+    /// <remarks>
+    /// A service provider must be registered in the service collection before calling this method.
+    /// Alternatively, if the <see cref="IServiceRegistry"/> instance is also an <see cref="IServiceProvider"/>, it will be registered as a singleton.
+    /// </remarks>
+    /// <param name="serviceRegistry">The service collection.</param>
+    /// <param name="configure">The configuration method.</param>
+    /// <param name="serviceLifetime">The service lifetime of the mediator and handlers.</param>
+    /// <returns>The service collection.</returns>
+    public static IServiceRegistry AppendSnowberryMediator(this IServiceRegistry serviceRegistry, Action<MediatorOptions> configure, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
+    {
+        return AddSnowberryMediator(serviceRegistry, configure, serviceLifetime, append: true);
+    }
+
+    /// <summary>
+    /// Adds the Mediator services to the specified <see cref="IServiceRegistry" />.
+    /// </summary>
+    /// <remarks>
+    /// A service provider must be registered in the service collection before calling this method.
+    /// Alternatively, if the <see cref="IServiceRegistry"/> instance is also an <see cref="IServiceProvider"/>, it will be registered as a singleton.
+    /// </remarks>
+    /// <param name="serviceRegistry">The service collection.</param>
+    /// <param name="configure">The configuration method.</param>
+    /// <param name="serviceLifetime">The service lifetime of the mediator and handlers.</param>
+    /// <param name="append">Whether to append the registrations to existing ones.</param>
+    /// <returns>The service collection.</returns>
+    private static IServiceRegistry AddSnowberryMediator(this IServiceRegistry serviceRegistry, Action<MediatorOptions> configure, ServiceLifetime serviceLifetime, bool append)
     {
         var options = new MediatorOptions();
         configure(options);
@@ -28,7 +65,7 @@ public static IServiceRegistry AddSnowberryMediator(this IServiceRegistry servic
             ServiceLifetime.Singleton => RegistrationServiceLifetime.Singleton,
             ServiceLifetime.Transient => RegistrationServiceLifetime.Transient,
             _ => throw new NotSupportedException($"The service lifetime '{serviceLifetime}' is not supported."),
-        });
+        }, append: append);
 
         if (!serviceRegistry.IsServiceRegistered<IServiceProvider>(serviceKey: null))
         {