feat(core)!: Improve DI robustness by removing unsafe casts

This commit addresses the fragility of using `Unsafe.As` for handling collections resolved from the service provider. This was causing potential runtime exceptions when using DI containers (like Autofac) that resolve `IEnumerable<T>` to `List<T>` instead of an array.

The unsafe casts have been replaced with safer, more idiomatic C# patterns that provide a zero-allocation fast path when the underlying collection is an array, while gracefully handling any other `IEnumerable<T>` implementation by converting it to an array.

This change significantly improves the library's robustness and compatibility without a meaningful performance regression for the common path.

BREAKING CHANGE: While unlikely to affect users, this changes the internal handling of collections and is a fundamental fix to the library's core resolution logic, warranting a major version bump for safety.

Resolves #29

Author: aminafra

src/DispatchR/Configuration/ServiceRegistrator.cs

@@ -1,7 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
-using System.Runtime.CompilerServices;
-using DispatchR.Abstractions.Notification;
+using DispatchR.Abstractions.Notification;
 using DispatchR.Abstractions.Send;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace DispatchR.Configuration
 {
@@ -143,10 +142,17 @@ public static void RegisterHandlers(IServiceCollection services, List<Type> allT
                         }
                     }
 
-                    services.AddScoped(handlerInterface, sp =>
+                services.AddScoped(handlerInterface, sp =>
+                {
+                    var keyedServices = sp.GetKeyedServices<IRequestHandler>(key);
+
+                    var pipelinesWithHandler = keyedServices as IRequestHandler[] ?? keyedServices.ToArray();
+
+                    // Single handler - no pipeline chaining needed
+                    if (pipelinesWithHandler.Length == 1)
                     {
-                        var pipelinesWithHandler = Unsafe
-                            .As<IRequestHandler[]>(sp.GetKeyedServices<IRequestHandler>(key));
+                        return pipelinesWithHandler[0];
+                    }
 
                         IRequestHandler lastPipeline = pipelinesWithHandler[0];
                         for (int i = 1; i < pipelinesWithHandler.Length; i++)

src/DispatchR/IMediator.cs

@@ -1,9 +1,9 @@
-using System.Runtime.CompilerServices;
-using DispatchR.Abstractions.Notification;
+using DispatchR.Abstractions.Notification;
 using DispatchR.Abstractions.Send;
 using DispatchR.Abstractions.Stream;
 using DispatchR.Exceptions;
 using Microsoft.Extensions.DependencyInjection;
+using System.Runtime.CompilerServices;
 
 namespace DispatchR;
 
@@ -17,7 +17,7 @@ IAsyncEnumerable<TResponse> CreateStream<TRequest, TResponse>(IStreamRequest<TRe
 
     ValueTask Publish<TNotification>(TNotification request, CancellationToken cancellationToken)
         where TNotification : INotification;
-    
+
     /// <summary>
     /// This method is not recommended for performance-critical scenarios.  
     /// Use it only if it is strictly necessary, as its performance is lower compared  
@@ -28,8 +28,8 @@ ValueTask Publish<TNotification>(TNotification request, CancellationToken cancel
     /// </param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    [Obsolete(message: "This method has performance issues. Use only if strictly necessary", 
-        error: false, 
+    [Obsolete(message: "This method has performance issues. Use only if strictly necessary",
+        error: false,
         DiagnosticId = Constants.DiagnosticPerformanceIssue)]
     ValueTask Publish(object request, CancellationToken cancellationToken);
 }
@@ -60,13 +60,29 @@ public IAsyncEnumerable<TResponse> CreateStream<TRequest, TResponse>(IStreamRequ
     public async ValueTask Publish<TNotification>(TNotification request, CancellationToken cancellationToken)
         where TNotification : INotification
     {
-        var notificationsInDi = serviceProvider.GetRequiredService<IEnumerable<INotificationHandler<TNotification>>>();
+        var handlers = serviceProvider.GetRequiredService<IEnumerable<INotificationHandler<TNotification>>>();
+
+        if (handlers is INotificationHandler<TNotification>[] handlerArray)
+        {
+            foreach (var handler in handlerArray)
+            {
+                await ProcessHandlerAsync(handler);
+            }
+        }
+        else
+        {
+            foreach (var handler in handlers)
+            {
+                await ProcessHandlerAsync(handler);
+            }
+        }
+
+        return;
 
-        var notifications = Unsafe.As<INotificationHandler<TNotification>[]>(notificationsInDi);
-        foreach (var notification in notifications)
+        async ValueTask ProcessHandlerAsync(INotificationHandler<TNotification> handler)
         {
-            var valueTask = notification.Handle(request, cancellationToken);
-            if (valueTask.IsCompletedSuccessfully is false)
+            var valueTask = handler.Handle(request, cancellationToken);
+            if (!valueTask.IsCompletedSuccessfully)
             {
                 await valueTask;
             }