Add ability to show all registered handlers

Author: ejsmith

samples/ModularMonolithSample/src/Orders.Module/Api/OrdersApi.cs

@@ -58,6 +58,9 @@ public static void MapOrdersEndpoints(this IEndpointRouteBuilder endpoints)
 
         group.MapPost("/action", async (EntityAction<Order> command, IMediator mediator) =>
         {
+            var foundatioMediator = (Mediator)mediator;
+            foundatioMediator.ShowRegisteredHandlers();
+
             var result = await mediator.InvokeAsync<Result<Order>>(command);
             return result.ToCreatedResult($"/api/orders/{result.Value?.Id}");
         })

src/Foundatio.Mediator.Abstractions/HandlerRegistration.cs

@@ -9,12 +9,14 @@ public class HandlerRegistration
     /// Creates a new handler registration
     /// </summary>
     /// <param name="messageTypeName">The fully qualified type name of the message</param>
+    /// <param name="handlerClassName">The fully qualified type name of the generated handler wrapper class</param>
     /// <param name="handleAsync">The delegate to handle the message asynchronously</param>
     /// <param name="handle">The delegate to handle the message synchronously (null for async-only handlers)</param>
     /// <param name="isAsync">Whether the handler supports async operations</param>
-    public HandlerRegistration(string messageTypeName, HandleAsyncDelegate handleAsync, HandleDelegate? handle, bool isAsync)
+    public HandlerRegistration(string messageTypeName, string handlerClassName, HandleAsyncDelegate handleAsync, HandleDelegate? handle, bool isAsync)
     {
         MessageTypeName = messageTypeName;
+        HandlerClassName = handlerClassName;
         HandleAsync = handleAsync;
         Handle = handle;
         IsAsync = isAsync;
@@ -25,6 +27,11 @@ public HandlerRegistration(string messageTypeName, HandleAsyncDelegate handleAsy
     /// </summary>
     public string MessageTypeName { get; }
 
+    /// <summary>
+    /// The fully qualified type name of the generated handler wrapper class
+    /// </summary>
+    public string HandlerClassName { get; }
+
     /// <summary>
     /// The delegate to handle the message
     /// </summary>

src/Foundatio.Mediator.Abstractions/Mediator.cs

@@ -1,6 +1,8 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Text;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace Foundatio.Mediator;
 
@@ -51,6 +53,26 @@ public ValueTask PublishAsync(object message, CancellationToken cancellationToke
         return _configuration.NotificationPublisher.PublishAsync(this, handlersList, message, cancellationToken);
     }
 
+    public void ShowRegisteredHandlers()
+    {
+        var logger = _serviceProvider.GetRequiredService<ILogger<Mediator>>();
+        var registrations = _serviceProvider.GetServices<HandlerRegistration>().ToArray();
+        if (!registrations.Any())
+        {
+            logger.LogInformation("No handlers registered.");
+            return;
+        }
+
+        var sb = new StringBuilder();
+        sb.AppendLine("Registered Handlers:");
+        foreach (var registration in registrations.OrderBy(r => r.MessageTypeName).ThenBy(r => r.HandlerClassName))
+        {
+            sb.AppendLine($"- Message: {registration.MessageTypeName}, Handler: {registration.HandlerClassName}, IsAsync: {registration.IsAsync}");
+        }
+
+        logger.LogInformation(sb.ToString());
+    }
+
     [DebuggerStepThrough]
     private InvokeAsyncDelegate GetInvokeAsyncDelegate(Type messageType)
     {

src/Foundatio.Mediator.Abstractions/MediatorExtensions.cs

@@ -57,6 +57,19 @@ public static IServiceCollection AddMediator(this IServiceCollection services, A
         return services.AddMediator(configurationBuilder.Build());
     }
 
+    /// <summary>
+    /// Adds a handler registration to the service collection.
+    /// </summary>
+    /// <param name="services"></param>
+    /// <param name="registration"></param>
+    /// <returns></returns>
+    public static IServiceCollection AddHandler(this IServiceCollection services, HandlerRegistration registration)
+    {
+        services.AddKeyedSingleton<HandlerRegistration>(registration.MessageTypeName);
+        services.AddSingleton(registration);
+        return services;
+    }
+
     private static bool IsAssemblyMarkedWithFoundatioHandlerModule(Assembly assembly)
     {
         return assembly.GetCustomAttributes(typeof(FoundatioHandlerModuleAttribute), false).Any();

src/Foundatio.Mediator/DIRegistrationGenerator.cs

@@ -59,9 +59,9 @@ public static void Execute(SourceProductionContext context, List<HandlerInfo> ha
             }
 
             // Use reflection FullName so nested types resolve with '+' and match runtime Type.FullName keys
-            source.AppendLine($"services.AddKeyedSingleton<HandlerRegistration>(MessageTypeKey.Get(typeof({handler.MessageType.FullName})),");
-            source.AppendLine($"    new HandlerRegistration(");
+            source.AppendLine($"services.AddHandler(new HandlerRegistration(");
             source.AppendLine($"        MessageTypeKey.Get(typeof({handler.MessageType.FullName})),");
+            source.AppendLine($"        \"{handlerClassName}\",");
 
             if (handler.IsAsync)
             {