Add XML docs, cleanup, and refactor MediatR extensions

- Add comprehensive XML documentation to public APIs, pipeline behaviors, notification publishers, and service registration classes
- Replace MediatR.* usings with EasyExtensions.Mediator.* equivalents and clean up namespaces
- Refactor code for style consistency: remove unnecessary static lambdas, add braces, and clarify LINQ usage
- Improve nullability handling and property initialization
- Enhance exception handling and validation in service registration and generic handler logic
- Clarify and document service registration process and pipeline behaviors
- Remove redundant code and ensure all public APIs are well-documented
- Overall, improve maintainability, clarity, and extensibility of the codebase

Author: Vadim Belov

Sources/EasyExtensions.Mediator/INotificationPublisher.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using System.Threading;
+using EasyExtensions.Mediator.Contracts;
 
 namespace EasyExtensions.Mediator
 {

Sources/EasyExtensions.Mediator/Internal/HandlersOrderer.cs

@@ -15,12 +15,12 @@ public static IList<object> Prioritize<TRequest>(IList<object> handlers, TReques
             }
 
             var requestObjectDetails = new ObjectDetails(request);
-            var handlerObjectsDetails = handlers.Select(static s => new ObjectDetails(s)).ToList();
+            var handlerObjectsDetails = handlers.Select(s => new ObjectDetails(s)).ToList();
 
             var uniqueHandlers = RemoveOverridden(handlerObjectsDetails).ToArray();
             Array.Sort(uniqueHandlers, requestObjectDetails);
 
-            return uniqueHandlers.Select(static s => s.Value).ToList();
+            return uniqueHandlers.Select(s => s.Value).ToList();
         }
 
         private static IEnumerable<ObjectDetails> RemoveOverridden(IList<ObjectDetails> handlersData)
@@ -45,7 +45,7 @@ private static IEnumerable<ObjectDetails> RemoveOverridden(IList<ObjectDetails>
                 }
             }
 
-            return handlersData.Where(static w => !w.IsOverridden);
+            return handlersData.Where(w => !w.IsOverridden);
         }
     }
 }

Sources/EasyExtensions.Mediator/MicrosoftExtensionsDI/MediatrServiceConfiguration.cs

@@ -1,15 +1,25 @@
-using System;
+using EasyExtensions.Mediator;
+using EasyExtensions.Mediator.Entities;
+using EasyExtensions.Mediator.NotificationPublishers;
+using EasyExtensions.Mediator.Pipeline;
+using EasyExtensions.Mediator.Registration;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using MediatR;
-using MediatR.Entities;
-using MediatR.NotificationPublishers;
-using MediatR.Pipeline;
-using MediatR.Registration;
 
+#pragma warning disable IDE0130 // Namespace does not match folder structure
 namespace Microsoft.Extensions.DependencyInjection
+#pragma warning restore IDE0130 // Namespace does not match folder structure
 {
+    /// <summary>
+    /// Provides configuration options for registering MediatR services and behaviors with a dependency injection
+    /// container.
+    /// </summary>
+    /// <remarks>Use this class to customize how MediatR handlers, behaviors, processors, and related services
+    /// are discovered and registered during application startup. Configuration options include assembly scanning,
+    /// service lifetimes, notification publishing strategies, and constraints for generic handler registration. Most
+    /// methods return the current instance to allow fluent configuration.</remarks>
     public class MediatRServiceConfiguration
     {
         /// <summary>
@@ -38,32 +48,32 @@ public class MediatRServiceConfiguration
         public ServiceLifetime Lifetime { get; set; } = ServiceLifetime.Transient;
 
         /// <summary>
-        /// Request exception action processor strategy. Default value is <see cref="DependencyInjection.RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions"/>
+        /// Request exception action processor strategy. Default value is <see cref="RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions"/>
         /// </summary>
         public RequestExceptionActionProcessorStrategy RequestExceptionActionProcessorStrategy { get; set; }
             = RequestExceptionActionProcessorStrategy.ApplyForUnhandledExceptions;
 
-        internal List<Assembly> AssembliesToRegister { get; } = new();
+        internal List<Assembly> AssembliesToRegister { get; } = new List<Assembly>();
 
         /// <summary>
         /// List of behaviors to register in specific order
         /// </summary>
-        public List<ServiceDescriptor> BehaviorsToRegister { get; } = new();
+        public List<ServiceDescriptor> BehaviorsToRegister { get; } = new List<ServiceDescriptor>();
 
         /// <summary>
         /// List of stream behaviors to register in specific order
         /// </summary>
-        public List<ServiceDescriptor> StreamBehaviorsToRegister { get; } = new();
+        public List<ServiceDescriptor> StreamBehaviorsToRegister { get; } = new List<ServiceDescriptor>();
 
         /// <summary>
         /// List of request pre processors to register in specific order
         /// </summary>
-        public List<ServiceDescriptor> RequestPreProcessorsToRegister { get; } = new();
+        public List<ServiceDescriptor> RequestPreProcessorsToRegister { get; } = new List<ServiceDescriptor>();
 
         /// <summary>
         /// List of request post processors to register in specific order
         /// </summary>
-        public List<ServiceDescriptor> RequestPostProcessorsToRegister { get; } = new();
+        public List<ServiceDescriptor> RequestPostProcessorsToRegister { get; } = new List<ServiceDescriptor>();
 
         /// <summary>
         /// Automatically register processors during assembly scanning
@@ -508,7 +518,5 @@ public MediatRServiceConfiguration AddOpenRequestPostProcessor(Type openBehavior
 
             return this;
         }
-
-
     }
 }

Sources/EasyExtensions.Mediator/MicrosoftExtensionsDI/RequestExceptionActionProcessorStrategy.cs

@@ -1,8 +1,24 @@
-namespace Microsoft.Extensions.DependencyInjection
+#pragma warning disable IDE0130 // Namespace does not match folder structure
+namespace Microsoft.Extensions.DependencyInjection
+#pragma warning restore IDE0130 // Namespace does not match folder structure
 {
+    /// <summary>
+    /// Specifies the strategy used to determine when to process actions in response to request exceptions.
+    /// </summary>
+    /// <remarks>Use this enumeration to control whether exception actions are applied only to unhandled
+    /// exceptions or to all exceptions encountered during request processing. This can be useful for customizing error
+    /// handling behavior in request pipelines.</remarks>
     public enum RequestExceptionActionProcessorStrategy
     {
+        /// <summary>
+        /// Gets or sets a value indicating whether the policy should be applied to unhandled exceptions.
+        /// </summary>
         ApplyForUnhandledExceptions,
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the operation should be applied to all exceptions, regardless of
+        /// type.
+        /// </summary>
         ApplyForAllExceptions
     }
 }

Sources/EasyExtensions.Mediator/MicrosoftExtensionsDI/ServiceCollectionExtensions.cs

@@ -1,10 +1,12 @@
+using EasyExtensions.Mediator;
+using EasyExtensions.Mediator.Pipeline;
+using EasyExtensions.Mediator.Registration;
 using System;
 using System.Linq;
-using MediatR;
-using MediatR.Pipeline;
-using MediatR.Registration;
 
+#pragma warning disable IDE0130 // Namespace does not match folder structure
 namespace Microsoft.Extensions.DependencyInjection
+#pragma warning restore IDE0130 // Namespace does not match folder structure
 {
     /// <summary>
     /// Extensions to scan for MediatR handlers and registers them.
@@ -46,13 +48,9 @@ public static IServiceCollection AddMediatR(this IServiceCollection services,
             {
                 throw new ArgumentException("No assemblies found to scan. Supply at least one assembly to scan for handlers.");
             }
-
             ServiceRegistrar.SetGenericRequestHandlerRegistrationLimitations(configuration);
-
             ServiceRegistrar.AddMediatRClassesWithTimeout(services, configuration);
-
             ServiceRegistrar.AddRequiredServices(services, configuration);
-
             return services;
         }
     }

Sources/EasyExtensions.Mediator/NotificationPublishers/ForeachAwaitPublisher.cs

@@ -15,6 +15,16 @@ namespace EasyExtensions.Mediator.NotificationPublishers
     /// </summary>
     public class ForeachAwaitPublisher : INotificationPublisher
     {
+        /// <summary>
+        /// Publishes a notification to all specified notification handler executors asynchronously.
+        /// </summary>
+        /// <remarks>Each handler in the collection is invoked in sequence. The operation completes when
+        /// all handlers have finished processing the notification. If the cancellation token is triggered, the
+        /// operation may be canceled before all handlers are invoked.</remarks>
+        /// <param name="handlerExecutors">A collection of notification handler executors that will process the notification. Cannot be null.</param>
+        /// <param name="notification">The notification to be published to each handler. Cannot be null.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the publish operation.</param>
+        /// <returns>A task that represents the asynchronous publish operation.</returns>
         public async Task Publish(IEnumerable<NotificationHandlerExecutor> handlerExecutors, INotification notification, CancellationToken cancellationToken)
         {
             foreach (var handler in handlerExecutors)

Sources/EasyExtensions.Mediator/NotificationPublishers/TaskWhenAllPublisher.cs

@@ -18,6 +18,14 @@ namespace EasyExtensions.Mediator.NotificationPublishers
     /// </summary>
     public class TaskWhenAllPublisher : INotificationPublisher
     {
+        /// <summary>
+        /// Invokes all notification handler executors for the specified notification and waits for their completion.
+        /// </summary>
+        /// <param name="handlerExecutors">A collection of handler executors to be invoked for the notification. Cannot be null.</param>
+        /// <param name="notification">The notification to be published to each handler. Cannot be null.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task completes when all handler executors have
+        /// finished processing the notification.</returns>
         public Task Publish(IEnumerable<NotificationHandlerExecutor> handlerExecutors, INotification notification, CancellationToken cancellationToken)
         {
             var tasks = handlerExecutors

Sources/EasyExtensions.Mediator/Pipeline/RequestExceptionActionProcessorBehavior.cs

@@ -1,3 +1,4 @@
+using EasyExtensions.Mediator.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
@@ -20,8 +21,26 @@ public class RequestExceptionActionProcessorBehavior<TRequest, TResponse> : IPip
     {
         private readonly IServiceProvider _serviceProvider;
 
+        /// <summary>
+        /// Initializes a new instance of the RequestExceptionActionProcessorBehavior class using the specified service
+        /// provider.
+        /// </summary>
+        /// <param name="serviceProvider">The service provider used to resolve dependencies required by the behavior. Cannot be null.</param>
         public RequestExceptionActionProcessorBehavior(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
 
+        /// <summary>
+        /// Handles the specified request by invoking the next handler in the pipeline and applying any registered
+        /// exception actions if an exception occurs.
+        /// </summary>
+        /// <remarks>If an exception is thrown during the execution of the next handler, any registered
+        /// exception actions for the exception type are invoked before the exception is rethrown. Exception actions are
+        /// executed in the order they are registered and may themselves throw exceptions.</remarks>
+        /// <param name="request">The request message to process. Cannot be null.</param>
+        /// <param name="next">A delegate representing the next handler in the pipeline to invoke. Cannot be null.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains the response produced by the
+        /// handler pipeline.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if an exception action method cannot be invoked or does not return a valid task.</exception>
         public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
         {
             try
@@ -34,9 +53,9 @@ public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TRe
 
                 var actionsForException = exceptionTypes
                     .SelectMany(exceptionType => GetActionsForException(exceptionType, request))
-                    .GroupBy(static actionForException => actionForException.Action.GetType())
-                    .Select(static actionForException => actionForException.First())
-                    .Select(static actionForException => (MethodInfo: GetMethodInfoForAction(actionForException.ExceptionType), actionForException.Action))
+                    .GroupBy(actionForException => actionForException.Action.GetType())
+                    .Select(actionForException => actionForException.First())
+                    .Select(actionForException => (MethodInfo: GetMethodInfoForAction(actionForException.ExceptionType), actionForException.Action))
                     .ToList();
 
                 foreach (var actionForException in actionsForException)

Sources/EasyExtensions.Mediator/Pipeline/RequestExceptionHandlerState.cs

@@ -14,7 +14,7 @@ public class RequestExceptionHandlerState<TResponse>
         /// <summary>
         /// The response that is returned if <see cref="Handled"/> is <code>true</code>.
         /// </summary>
-        public TResponse? Response { get; private set; }
+        public TResponse Response { get; private set; } = default!;
 
         /// <summary>
         /// Call to indicate whether the current exception should be considered handled and the specified response should be returned.

Sources/EasyExtensions.Mediator/Pipeline/RequestExceptionProcessorBehavior.cs

@@ -1,3 +1,4 @@
+using EasyExtensions.Mediator.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
@@ -20,8 +21,27 @@ public class RequestExceptionProcessorBehavior<TRequest, TResponse> : IPipelineB
     {
         private readonly IServiceProvider _serviceProvider;
 
+        /// <summary>
+        /// Initializes a new instance of the RequestExceptionProcessorBehavior class using the specified service
+        /// provider.
+        /// </summary>
+        /// <param name="serviceProvider">The service provider used to resolve dependencies required by the behavior. Cannot be null.</param>
         public RequestExceptionProcessorBehavior(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
 
+        /// <summary>
+        /// Handles the request by invoking the next handler in the pipeline and processes any exceptions using
+        /// registered exception handlers.
+        /// </summary>
+        /// <remarks>If an exception occurs during request processing, registered exception handlers are
+        /// invoked in order of specificity. If an exception is handled and a response is provided, that response is
+        /// returned; otherwise, the original exception is rethrown.</remarks>
+        /// <param name="request">The request message to be handled. Cannot be null.</param>
+        /// <param name="next">A delegate representing the next handler in the pipeline. Cannot be null.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used to cancel the operation.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains the response produced by the
+        /// handler or an exception handler.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if an exception handler does not return a Task or if the exception is marked as handled but no
+        /// response is provided.</exception>
         public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancellationToken)
         {
             try
@@ -36,9 +56,9 @@ public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TRe
 
                 var handlersForException = exceptionTypes
                     .SelectMany(exceptionType => GetHandlersForException(exceptionType, request))
-                    .GroupBy(static handlerForException => handlerForException.Handler.GetType())
-                    .Select(static handlerForException => handlerForException.First())
-                    .Select(static handlerForException => (MethodInfo: GetMethodInfoForHandler(handlerForException.ExceptionType), handlerForException.Handler))
+                    .GroupBy(handlerForException => handlerForException.Handler.GetType())
+                    .Select(handlerForException => handlerForException.First())
+                    .Select(handlerForException => (MethodInfo: GetMethodInfoForHandler(handlerForException.ExceptionType), handlerForException.Handler))
                     .ToList();
 
                 foreach (var handlerForException in handlersForException)
@@ -86,21 +106,16 @@ private static IEnumerable<Type> GetExceptionTypes(Type? exceptionType)
         {
             var exceptionHandlerInterfaceType = typeof(IRequestExceptionHandler<,,>).MakeGenericType(typeof(TRequest), typeof(TResponse), exceptionType);
             var enumerableExceptionHandlerInterfaceType = typeof(IEnumerable<>).MakeGenericType(exceptionHandlerInterfaceType);
-
             var exceptionHandlers = (IEnumerable<object>)_serviceProvider.GetRequiredService(enumerableExceptionHandlerInterfaceType);
-
             return HandlersOrderer.Prioritize(exceptionHandlers.ToList(), request)
                 .Select(handler => (exceptionType, action: handler));
         }
 
         private static MethodInfo GetMethodInfoForHandler(Type exceptionType)
         {
             var exceptionHandlerInterfaceType = typeof(IRequestExceptionHandler<,,>).MakeGenericType(typeof(TRequest), typeof(TResponse), exceptionType);
-
-            var handleMethodInfo = exceptionHandlerInterfaceType.GetMethod(nameof(IRequestExceptionHandler<TRequest, TResponse, Exception>.Handle))
-                               ?? throw new InvalidOperationException($"Could not find method {nameof(IRequestExceptionHandler<TRequest, TResponse, Exception>.Handle)} on type {exceptionHandlerInterfaceType}");
-
-            return handleMethodInfo;
+            return exceptionHandlerInterfaceType.GetMethod(nameof(IRequestExceptionHandler<TRequest, TResponse, Exception>.Handle))
+                ?? throw new InvalidOperationException($"Could not find method {nameof(IRequestExceptionHandler<TRequest, TResponse, Exception>.Handle)} on type {exceptionHandlerInterfaceType}");
         }
     }
 }