refactor handler descriptors

src/LiteBus.Messaging.Abstractions/ILazyHandlerCollection.cs

@@ -2,6 +2,6 @@
 
 namespace LiteBus.Messaging.Abstractions;
 
-public interface ILazyHandlerCollection<THandler, TDescriptor> : IReadOnlyCollection<LazyHandler<THandler, TDescriptor>>
+public interface ILazyHandlerCollection<THandler, TDescriptor> : IReadOnlyCollection<LazyHandler<THandler, TDescriptor>> where TDescriptor : IHandlerDescriptor
 {
 }

src/LiteBus.Messaging.Abstractions/IMessageDependencies.cs

@@ -11,15 +11,15 @@ public interface IMessageDependencies
     /// <value>
     /// The collection of direct message handlers.
     /// </value>
-    ILazyHandlerCollection<IMessageHandler, IHandlerDescriptor> Handlers { get; }
+    ILazyHandlerCollection<IMessageHandler, IMainHandlerDescriptor> Handlers { get; }
 
     /// <summary>
     /// Gets a lazy initialized read-only collection of indirect message handlers. These handlers can be used to handle messages in a more general manner, potentially handling a variety of different message types or performing logging or other cross-cutting concerns.
     /// </summary>
     /// <value>
     /// The collection of indirect message handlers.
     /// </value>
-    ILazyHandlerCollection<IMessageHandler, IHandlerDescriptor> IndirectHandlers { get; }
+    ILazyHandlerCollection<IMessageHandler, IMainHandlerDescriptor> IndirectHandlers { get; }
 
     /// <summary>
     /// Gets a lazy initialized read-only collection of direct pre-message handlers. These handlers are invoked before the primary message handlers and can be used for tasks such as validation or logging.

src/LiteBus.Messaging.Abstractions/LiteBus.Messaging.Abstractions.csproj.DotSettings

@@ -14,4 +14,6 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mainhandle/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=mediationstrategies/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=posthandle/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=prehandle/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=prehandle/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=registry/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=registry_005Cdescriptors/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IErrorHandlerDescriptor.cs

@@ -0,0 +1,9 @@
+namespace LiteBus.Messaging.Abstractions;
+
+/// <summary>
+/// Represents a descriptor for an error handler, providing metadata about the handler such as the message type it handles,
+/// its execution order, and any associated tags.
+/// </summary>
+public interface IErrorHandlerDescriptor : IHandlerDescriptor
+{
+}

src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IHandlerDescriptor.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+
+namespace LiteBus.Messaging.Abstractions;
+
+/// <summary>
+/// Represents a descriptor for a handler, providing metadata about the handler such as the message type it handles,
+/// its execution order, and any associated tags.
+/// </summary>
+public interface IHandlerDescriptor
+{
+    /// <summary>
+    /// Gets the type of the message that the handler is associated with. If the message type is generic,
+    /// this property returns the generic type definition.
+    /// </summary>
+    Type MessageType { get; }
+
+    /// <summary>
+    /// Gets the order in which the handler should be executed. Handlers with lower order values are executed first.
+    /// </summary>
+    int Order { get; }
+
+    /// <summary>
+    /// Gets a collection of tags associated with the handler. Tags can be used to categorize or identify handlers in a flexible way.
+    /// </summary>
+    IReadOnlyCollection<string> Tags { get; }
+
+    /// <summary>
+    /// Gets the type of the handler. This represents the actual implementation type of the handler.
+    /// </summary>
+    Type HandlerType { get; }
+}

src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IMainHandlerDescriptor.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace LiteBus.Messaging.Abstractions;
+
+/// <summary>
+/// Represents a descriptor for a main handler, providing metadata about the handler such as the message type it handles,
+/// its execution order, any associated tags, and the type of the result produced by the handler.
+/// </summary>
+public interface IMainHandlerDescriptor : IHandlerDescriptor
+{
+    /// <summary>
+    /// Gets the type of the result produced by the main handler.
+    /// </summary>
+    Type MessageResultType { get; }
+}

src/LiteBus.Messaging.Abstractions/Descriptors/IMessageDescriptor.cs → src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IMessageDescriptor.cs

@@ -1,14 +1,17 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace LiteBus.Messaging.Abstractions;
 
-public interface IMessageDescriptor : IDescriptor
+public interface IMessageDescriptor
 {
+    Type MessageType { get; }
+
     bool IsGeneric { get; }
 
-    IReadOnlyCollection<IHandlerDescriptor> Handlers { get; }
+    IReadOnlyCollection<IMainHandlerDescriptor> Handlers { get; }
 
-    IReadOnlyCollection<IHandlerDescriptor> IndirectHandlers { get; }
+    IReadOnlyCollection<IMainHandlerDescriptor> IndirectHandlers { get; }
 
     IReadOnlyCollection<IPostHandlerDescriptor> PostHandlers { get; }
 

src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IPostHandlerDescriptor.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace LiteBus.Messaging.Abstractions;
+
+/// <summary>
+/// Represents a descriptor for a post-handler, providing metadata about the handler such as the message type it handles,
+/// its execution order, any associated tags, and the type of the result that is expected by the user as an argument.
+/// </summary>
+public interface IPostHandlerDescriptor : IHandlerDescriptor
+{
+    /// <summary>
+    /// Gets the type of the result produced by the main handler that is associated with this post-handler.
+    /// </summary>
+    Type MessageResultType { get; }
+}

src/LiteBus.Messaging.Abstractions/Registry/Descriptors/IPreHandlerDescriptor.cs

@@ -0,0 +1,9 @@
+namespace LiteBus.Messaging.Abstractions;
+
+/// <summary>
+/// Represents a descriptor for a pre-handler, providing metadata about the handler such as the message type it handles,
+/// its execution order, and any associated tags.
+/// </summary>
+public interface IPreHandlerDescriptor : IHandlerDescriptor
+{
+}

src/LiteBus.Messaging.Extensions.MicrosoftDependencyInjection/ModuleRegistry.cs

@@ -63,17 +63,17 @@ public void Initialize()
 
             foreach (var postHandleDescriptor in descriptor.PostHandlers.Concat(descriptor.IndirectPostHandlers))
             {
-                _services.TryAddTransient(postHandleDescriptor.PostHandlerType);
+                _services.TryAddTransient(postHandleDescriptor.HandlerType);
             }
 
             foreach (var preHandleDescriptor in descriptor.PreHandlers.Concat(descriptor.IndirectPreHandlers))
             {
-                _services.TryAddTransient(preHandleDescriptor.PreHandlerType);
+                _services.TryAddTransient(preHandleDescriptor.HandlerType);
             }
 
             foreach (var errorHandlerDescriptor in descriptor.ErrorHandlers.Concat(descriptor.IndirectErrorHandlers))
             {
-                _services.TryAddTransient(errorHandlerDescriptor.ErrorHandlerType);
+                _services.TryAddTransient(errorHandlerDescriptor.HandlerType);
             }
         }
     }

src/LiteBus.Messaging/Internal/Extensions/EnumerableExtensions.cs

@@ -6,6 +6,7 @@ namespace LiteBus.Messaging.Internal.Extensions;
 public static class EnumerableExtensions
 {
     public static ILazyHandlerCollection<THandler, TDescriptor> ToLazyReadOnlyCollection<THandler, TDescriptor>(this IEnumerable<LazyHandler<THandler, TDescriptor>> source)
+        where TDescriptor : IHandlerDescriptor
     {
         return new LazyHandlerCollection<THandler, TDescriptor>(source);
     }

src/LiteBus.Messaging/Internal/LazyReadOnlyCollection[T].cs

@@ -4,7 +4,7 @@
 
 namespace LiteBus.Messaging.Internal;
 
-public sealed class LazyHandlerCollection<THandler, TDescriptor> : ILazyHandlerCollection<THandler, TDescriptor>
+public sealed class LazyHandlerCollection<THandler, TDescriptor> : ILazyHandlerCollection<THandler, TDescriptor> where TDescriptor : IHandlerDescriptor
 {
     private readonly List<LazyHandler<THandler, TDescriptor>> _list;
 

src/LiteBus.Messaging/Internal/Mediator/MessageDependencies.cs

@@ -28,9 +28,9 @@ public MessageDependencies(Type messageType, IMessageDescriptor descriptor, ISer
         IndirectErrorHandlers = ResolveHandlers(descriptor.IndirectErrorHandlers, (handlerType) => (IMessageErrorHandler) serviceProvider.GetService(handlerType));
     }
 
-    public ILazyHandlerCollection<IMessageHandler, IHandlerDescriptor> Handlers { get; }
+    public ILazyHandlerCollection<IMessageHandler, IMainHandlerDescriptor> Handlers { get; }
 
-    public ILazyHandlerCollection<IMessageHandler, IHandlerDescriptor> IndirectHandlers { get; }
+    public ILazyHandlerCollection<IMessageHandler, IMainHandlerDescriptor> IndirectHandlers { get; }
 
     public ILazyHandlerCollection<IMessagePreHandler, IPreHandlerDescriptor> PreHandlers { get; }
 
@@ -49,10 +49,10 @@ public MessageDependencies(Type messageType, IMessageDescriptor descriptor, ISer
     /// </summary>
     private ILazyHandlerCollection<THandler, TDescriptor> ResolveHandlers<THandler, TDescriptor>(
         IEnumerable<TDescriptor> descriptors,
-        Func<Type, THandler> resolveFunc)
+        Func<Type, THandler> resolveFunc) where TDescriptor : IHandlerDescriptor
     {
         return descriptors
-            .OrderBy(d => GetOrder(d))
+            .OrderBy(d => d.Order)
             .Select(d => new LazyHandler<THandler, TDescriptor>
             {
                 Handler = new Lazy<THandler>(() => resolveFunc(GetHandlerType(d))),
@@ -61,27 +61,14 @@ private ILazyHandlerCollection<THandler, TDescriptor> ResolveHandlers<THandler,
             .ToLazyReadOnlyCollection();
     }
 
-    /// <summary>
-    /// Retrieves the order value from a descriptor.
-    /// </summary>
-    private static int GetOrder(object descriptor)
-    {
-        return (int) descriptor.GetType().GetProperty("Order").GetValue(descriptor);
-    }
-
     /// <summary>
     /// Retrieves the handler type from a descriptor, adjusting for generic types as necessary.
     /// </summary>
-    private Type GetHandlerType(object descriptor)
+    private Type GetHandlerType(IHandlerDescriptor descriptor)
     {
-        var handlerTypeProp = descriptor.GetType().GetProperty("HandlerType") ??
-                              descriptor.GetType().GetProperty($"{descriptor.GetType().Name.Replace("Descriptor", string.Empty)}Type");
-
-        var isGenericProp = descriptor.GetType().GetProperty("IsGeneric");
-
-        var handlerType = (Type) handlerTypeProp.GetValue(descriptor);
+        var handlerType = descriptor.HandlerType;
 
-        if ((bool) isGenericProp.GetValue(descriptor))
+        if (descriptor.MessageType.IsGenericType)
         {
             handlerType = handlerType.MakeGenericType(_messageType.GetGenericArguments());
         }

src/LiteBus.Messaging/Internal/Registry/Abstractions/IDescriptorBuilder.cs → src/LiteBus.Messaging/Internal/Registry/Abstractions/IHandlerDescriptorBuilder.cs

@@ -4,9 +4,9 @@
 
 namespace LiteBus.Messaging.Internal.Registry.Abstractions;
 
-internal interface IDescriptorBuilder
+internal interface IHandlerDescriptorBuilder
 {
     bool CanBuild(Type type);
 
-    IEnumerable<IDescriptor> Build(Type type);
+    IEnumerable<IHandlerDescriptor> Build(Type type);
 }

src/LiteBus.Messaging/Internal/Registry/Builders/ErrorHandlerDescriptorBuilder.cs

@@ -7,22 +7,31 @@
 
 namespace LiteBus.Messaging.Internal.Registry.Builders;
 
-internal sealed class ErrorHandlerDescriptorBuilder : IDescriptorBuilder<IErrorHandlerDescriptor>
+internal sealed class ErrorHandlerDescriptorBuilder : IHandlerDescriptorBuilder
 {
     public bool CanBuild(Type type)
     {
         return type.IsAssignableTo(typeof(IMessageErrorHandler));
     }
 
-    public IEnumerable<IErrorHandlerDescriptor> Build(Type handlerType)
+    public IEnumerable<IHandlerDescriptor> Build(Type handlerType)
     {
         var interfaces = handlerType.GetInterfacesEqualTo(typeof(IMessageErrorHandler<,>));
         var order = handlerType.GetOrderFromAttribute();
 
         foreach (var @interface in interfaces)
         {
             var messageType = @interface.GetGenericArguments()[0];
-            yield return new ErrorHandlerDescriptor(handlerType, messageType, order);
+            var messageResultType = @interface.GetGenericArguments()[1];
+
+            yield return new ErrorHandlerDescriptor
+            {
+                MessageType = messageType.IsGenericType ? messageType.GetGenericTypeDefinition() : messageType,
+                MessageResultType = messageResultType,
+                Order = order,
+                Tags = ArraySegment<string>.Empty,
+                HandlerType = handlerType,
+            };
         }
     }
 }