[WIP] Fix inconsistent projection name resolution in event handling

src/BbQ.Events/Engine/DefaultProjectionEngine.cs

@@ -224,7 +224,7 @@
         {
 
             // Check interfaces for explicit implementation
             foreach (var iface in type.GetInterfaces())
             {
                 var map = type.GetInterfaceMap(iface);
                 for (int i = 0; i < map.InterfaceMethods.Length; i++)
@@ -252,7 +252,7 @@
         {
 
             // Check interfaces for explicit implementation
             foreach (var iface in type.GetInterfaces())
             {
                 var map = type.GetInterfaceMap(iface);
                 for (int i = 0; i < map.InterfaceMethods.Length; i++)
@@ -377,16 +377,21 @@
         // Fall back to reading from attribute
         var attribute = concreteType.GetCustomAttribute<ProjectionAttribute>();
 
-        return new ProjectionOptions
+        var options = new ProjectionOptions
         {
-            ProjectionName = concreteType.Name,
             MaxDegreeOfParallelism = attribute?.MaxDegreeOfParallelism ?? 1,
             CheckpointBatchSize = attribute?.CheckpointBatchSize ?? 100,
             StartupMode = attribute?.StartupMode ?? ProjectionStartupMode.Resume,
             ChannelCapacity = attribute?.ChannelCapacity ?? 1000,
             BackpressureStrategy = attribute?.BackpressureStrategy ?? BackpressureStrategy.Block,
             // ErrorHandling is already initialized by property initializer to default values
         };
+
+        // Use ProjectionNameResolver for consistent name resolution
+        // Since ProjectionName is not explicitly set in options, the resolver will use the type name
+        options.ProjectionName = ProjectionNameResolver.Resolve(concreteType, options);
+
+        return options;
     }
 
     /// <summary>

src/BbQ.Events/Engine/DefaultProjectionRebuilder.cs

@@ -134,7 +134,9 @@ public IEnumerable<string> GetRegisteredProjections()
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
                 if (registration != null)
                 {
-                    projectionNames.Add(registration.ConcreteType.Name);
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    projectionNames.Add(resolvedName);
                 }
             }
         }

src/BbQ.Events/Engine/DefaultReplayService.cs

@@ -102,7 +102,9 @@ public async Task ReplayAsync(
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
                 if (registration != null)
                 {
-                    registeredProjections.Add(registration.ConcreteType.Name);
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    registeredProjections.Add(resolvedName);
                 }
             }
         }
@@ -241,13 +243,18 @@ private async Task StreamEventsAndProcessAsync(
             foreach (var handlerType in handlers)
             {
                 var registration = ProjectionHandlerRegistry.GetHandlerRegistration(eventType, handlerType);
-                if (registration != null && registration.ConcreteType.Name == projectionName)
+                if (registration != null)
                 {
-                    if (!projectionHandlers.ContainsKey(eventType))
+                    var projectionOptions = ProjectionHandlerRegistry.GetProjectionOptions(registration.ConcreteType.Name);
+                    var resolvedName = ProjectionNameResolver.Resolve(registration.ConcreteType, projectionOptions);
+                    if (resolvedName == projectionName)
                     {
-                        projectionHandlers[eventType] = new List<Type>();
+                        if (!projectionHandlers.ContainsKey(eventType))
+                        {
+                            projectionHandlers[eventType] = new List<Type>();
+                        }
+                        projectionHandlers[eventType].Add(handlerType);
                     }
-                    projectionHandlers[eventType].Add(handlerType);
                 }
             }
         }

src/BbQ.Events/Engine/ProjectionNameResolver.cs

@@ -0,0 +1,43 @@
+namespace BbQ.Events.Engine;
+
+/// <summary>
+/// Provides consistent projection name resolution across all projection components.
+/// </summary>
+/// <remarks>
+/// This resolver ensures that projection names are resolved using the same logic everywhere:
+/// - DefaultProjectionEngine (runtime processing)
+/// - DefaultReplayService (replay operations)
+/// - DefaultProjectionRebuilder (rebuild operations)
+/// 
+/// Resolution logic:
+/// 1. If ProjectionOptions.ProjectionName is set and not empty → use it
+/// 2. Otherwise → use the projection type name
+/// 
+/// This consistency prevents mismatched projection identifiers between runtime processing
+/// and replay/rebuild operations.
+/// </remarks>
+public static class ProjectionNameResolver
+{
+    /// <summary>
+    /// Resolves the projection name for a given projection type and options.
+    /// </summary>
+    /// <param name="projectionType">The concrete type of the projection handler.</param>
+    /// <param name="options">Optional projection options that may contain an explicit projection name.</param>
+    /// <returns>The resolved projection name.</returns>
+    public static string Resolve(Type projectionType, ProjectionOptions? options)
+    {
+        if (projectionType == null)
+        {
+            throw new ArgumentNullException(nameof(projectionType));
+        }
+
+        // If ProjectionOptions.ProjectionName is explicitly set, use it
+        if (!string.IsNullOrWhiteSpace(options?.ProjectionName))
+        {
+            return options.ProjectionName;
+        }
+
+        // Otherwise, fall back to the projection type name
+        return projectionType.Name;
+    }
+}

tests/BbQ.Cqrs.Tests/ProjectionNameResolverTests.cs

@@ -0,0 +1,140 @@
+using BbQ.Events.Engine;
+using NUnit.Framework;
+
+namespace BbQ.Cqrs.Tests;
+
+/// <summary>
+/// Tests for ProjectionNameResolver to ensure consistent projection name resolution.
+/// </summary>
+[TestFixture]
+public class ProjectionNameResolverTests
+{
+    // Test projection class
+    private class TestProjection { }
+
+    [Test]
+    public void Resolve_WithNullProjectionType_ThrowsArgumentNullException()
+    {
+        // Act & Assert
+        Assert.Throws<ArgumentNullException>(() => 
+            ProjectionNameResolver.Resolve(null!, null));
+    }
+
+    [Test]
+    public void Resolve_WithNullOptions_ReturnsTypeName()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+
+        // Act
+        var result = ProjectionNameResolver.Resolve(projectionType, null);
+
+        // Assert
+        Assert.That(result, Is.EqualTo("TestProjection"));
+    }
+
+    [Test]
+    public void Resolve_WithOptionsButNullProjectionName_ReturnsTypeName()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+        var options = new ProjectionOptions
+        {
+            ProjectionName = null!
+        };
+
+        // Act
+        var result = ProjectionNameResolver.Resolve(projectionType, options);
+
+        // Assert
+        Assert.That(result, Is.EqualTo("TestProjection"));
+    }
+
+    [Test]
+    public void Resolve_WithOptionsAndEmptyProjectionName_ReturnsTypeName()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+        var options = new ProjectionOptions
+        {
+            ProjectionName = string.Empty
+        };
+
+        // Act
+        var result = ProjectionNameResolver.Resolve(projectionType, options);
+
+        // Assert
+        Assert.That(result, Is.EqualTo("TestProjection"));
+    }
+
+    [Test]
+    public void Resolve_WithOptionsAndWhitespaceProjectionName_ReturnsTypeName()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+        var options = new ProjectionOptions
+        {
+            ProjectionName = "   "
+        };
+
+        // Act
+        var result = ProjectionNameResolver.Resolve(projectionType, options);
+
+        // Assert
+        Assert.That(result, Is.EqualTo("TestProjection"));
+    }
+
+    [Test]
+    public void Resolve_WithOptionsAndCustomProjectionName_ReturnsCustomName()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+        var customName = "CustomProjectionName";
+        var options = new ProjectionOptions
+        {
+            ProjectionName = customName
+        };
+
+        // Act
+        var result = ProjectionNameResolver.Resolve(projectionType, options);
+
+        // Assert
+        Assert.That(result, Is.EqualTo(customName));
+    }
+
+    [Test]
+    public void Resolve_WithDifferentProjectionTypes_ReturnsCorrectTypeNames()
+    {
+        // Arrange & Act & Assert
+        Assert.That(
+            ProjectionNameResolver.Resolve(typeof(TestProjection), null),
+            Is.EqualTo("TestProjection"));
+
+        Assert.That(
+            ProjectionNameResolver.Resolve(typeof(ProjectionNameResolverTests), null),
+            Is.EqualTo("ProjectionNameResolverTests"));
+
+        Assert.That(
+            ProjectionNameResolver.Resolve(typeof(string), null),
+            Is.EqualTo("String"));
+    }
+
+    [Test]
+    public void Resolve_ConsistencyBetweenCalls_ReturnsSameResult()
+    {
+        // Arrange
+        var projectionType = typeof(TestProjection);
+        var options = new ProjectionOptions
+        {
+            ProjectionName = "ConsistentName"
+        };
+
+        // Act
+        var result1 = ProjectionNameResolver.Resolve(projectionType, options);
+        var result2 = ProjectionNameResolver.Resolve(projectionType, options);
+
+        // Assert
+        Assert.That(result1, Is.EqualTo(result2));
+        Assert.That(result1, Is.EqualTo("ConsistentName"));
+    }
+}