ignore abstract classes in registration

src/DispatchR/Configuration/ServiceRegistrator.cs

@@ -170,28 +170,29 @@ public static void RegisterHandlers(IServiceCollection services, List<Type> allT
             }
         }
 
-        public static void RegisterNotification(IServiceCollection services, List<Type> allTypes,
-            Type syncNotificationHandlerType)
-        {
-            var allNotifications = allTypes
-                .SelectMany(handlerType => handlerType.GetInterfaces()
-                    .Where(i => i.IsGenericType && syncNotificationHandlerType == i.GetGenericTypeDefinition())
-                    .Select(i => new { HandlerType = handlerType, Interface = i }))
-                .ToList();
-
-            foreach (var notification in allNotifications)
-            {
-                var serviceType = notification.Interface;
-                var implementationType = notification.HandlerType;
-
+        public static void RegisterNotification(IServiceCollection services, List<Type> allTypes,
+            Type syncNotificationHandlerType)
+        {
+            var allNotifications = allTypes
+                .Where(handlerType => handlerType.IsClass && !handlerType.IsAbstract)
+                .SelectMany(handlerType => handlerType.GetInterfaces()
+                    .Where(i => i.IsGenericType && syncNotificationHandlerType == i.GetGenericTypeDefinition())
+                    .Select(i => new { HandlerType = handlerType, Interface = i }))
+                .ToList();
+
+            foreach (var notification in allNotifications)
+            {
+                var serviceType = notification.Interface;
+                var implementationType = notification.HandlerType;
+
                 if (serviceType.ContainsGenericParameters)
                 {
                     serviceType = serviceType.GetGenericTypeDefinition();
-                }
-
-                services.AddScoped(serviceType, implementationType);
-            }
-        }
+                }
+
+                services.AddScoped(serviceType, implementationType);
+            }
+        }
 
         private static bool IsAwaitable(Type type)
         {
@@ -208,4 +209,4 @@ private static bool IsAwaitable(Type type)
             return false;
         }
     }
-}
+}

tests/DispatchR.TestCommon/Fixtures/Notification/AbstractNotificationHandler.cs

@@ -0,0 +1,8 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public abstract class AbstractNotificationHandler : INotificationHandler<OpenGenericTargetNotification>
+{
+    public abstract ValueTask Handle(OpenGenericTargetNotification request, CancellationToken cancellationToken);
+}

tests/DispatchR.TestCommon/Fixtures/Notification/ConcreteWorkflowEvent.cs

@@ -0,0 +1,3 @@
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed record ConcreteWorkflowEvent : IWorkflowEvent;

tests/DispatchR.TestCommon/Fixtures/Notification/ConcreteWorkflowNotificationHandler.cs

@@ -0,0 +1,11 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed class ConcreteWorkflowNotificationHandler : INotificationHandler<WorkflowNotification<ConcreteWorkflowEvent>>
+{
+    public ValueTask Handle(WorkflowNotification<ConcreteWorkflowEvent> request, CancellationToken cancellationToken)
+    {
+        return ValueTask.CompletedTask;
+    }
+}

tests/DispatchR.TestCommon/Fixtures/Notification/IWorkflowEvent.cs

@@ -0,0 +1,3 @@
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public interface IWorkflowEvent;

tests/DispatchR.TestCommon/Fixtures/Notification/IWorkflowNotificationHandler.cs

@@ -0,0 +1,6 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public interface IWorkflowNotificationHandler<TNotification> : INotificationHandler<WorkflowNotification<TNotification>>
+    where TNotification : IWorkflowEvent;

tests/DispatchR.TestCommon/Fixtures/Notification/WorkflowNotification.cs

@@ -0,0 +1,6 @@
+using DispatchR.Abstractions.Notification;
+
+namespace DispatchR.TestCommon.Fixtures.Notification;
+
+public sealed record WorkflowNotification<TNotification>(TNotification Event) : INotification
+    where TNotification : IWorkflowEvent;

tests/DispatchR.UnitTest/AddDispatchRConfigurationTests.cs

@@ -327,4 +327,32 @@ p.ImplementationType is not null &&
 
         Assert.NotNull(openGenericHandler);
     }
+
+    [Fact]
+    public void AddDispatchR_RegisterNotifications_SkipsInterfaceAndAbstractHandlers()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+
+        // Act
+        services.AddDispatchR(cfg =>
+        {
+            cfg.Assemblies.Add(typeof(Fixture).Assembly);
+            cfg.RegisterPipelines = false;
+            cfg.RegisterNotifications = true;
+        });
+
+        // Assert
+        Assert.DoesNotContain(services, p =>
+            p.IsKeyedService is false &&
+            p.ImplementationType == typeof(AbstractNotificationHandler));
+
+        Assert.DoesNotContain(services, p =>
+            p.IsKeyedService is false &&
+            p.ImplementationType == typeof(IWorkflowNotificationHandler<>));
+
+        Assert.Contains(services, p =>
+            p.IsKeyedService is false &&
+            p.ImplementationType == typeof(ConcreteWorkflowNotificationHandler));
+    }
 }