Register Middlewares as Transient to avoid clobber

src/JustSaying.Extensions.DependencyInjection.Microsoft/IServiceCollectionExtensions.cs

@@ -116,7 +116,7 @@ public static IServiceCollection AddJustSaying(this IServiceCollection services,
         {
             throw new ArgumentNullException(nameof(configure));
         }
-
+        
         // Register as self so the same singleton instance implements two different interfaces
         services.TryAddSingleton((p) => new ServiceProviderResolver(p));
         services.TryAddSingleton<IHandlerResolver>((p) => p.GetRequiredService<ServiceProviderResolver>());
@@ -127,8 +127,8 @@ public static IServiceCollection AddJustSaying(this IServiceCollection services,
         services.TryAddSingleton<IMessagingConfig, MessagingConfig>();
         services.TryAddSingleton<IMessageMonitor, NullOpMessageMonitor>();
 
-        services.TryAddSingleton<LoggingMiddleware>();
-        services.TryAddSingleton<SqsPostProcessorMiddleware>();
+        services.TryAddTransient<LoggingMiddleware>();
+        services.TryAddTransient<SqsPostProcessorMiddleware>();
 
         services.AddSingleton<MessageContextAccessor>();
         services.TryAddSingleton<IMessageContextAccessor>(serviceProvider => serviceProvider.GetRequiredService<MessageContextAccessor>());

src/JustSaying.Extensions.DependencyInjection.StructureMap/JustSayingRegistry.cs

@@ -38,8 +38,8 @@ public JustSayingRegistry()
         For<IMessageContextAccessor>().Use(context => context.GetInstance<MessageContextAccessor>());
         For<IMessageContextReader>().Use(context => context.GetInstance<MessageContextAccessor>());
 
-        For<LoggingMiddleware>().Singleton();
-        For<SqsPostProcessorMiddleware>().Singleton();
+        For<LoggingMiddleware>().Transient();
+        For<SqsPostProcessorMiddleware>().Transient();
 
         For<IMessageSerializationRegister>()
             .Use(
@@ -56,4 +56,4 @@ public JustSayingRegistry()
         For<ITopicNamingConvention>().Use(context => context.GetInstance<DefaultNamingConventions>());
         For<IQueueNamingConvention>().Use(context => context.GetInstance<DefaultNamingConventions>());
     }
-}
+}

src/JustSaying/Messaging/Middleware/Handle/HandlerMiddlewareBuilder.cs

@@ -38,9 +38,19 @@ public HandlerMiddlewareBuilder(IHandlerResolver handlerResolver, IServiceResolv
     /// </summary>
     /// <typeparam name="TMiddleware">The type of the middleware to add.</typeparam>
     /// <returns>The current HandlerMiddlewareBuilder.</returns>
+    /// <exception cref="InvalidOperationException">When the middleware is not registered as Transient, an exception will be thrown if the resolved middleware is already part of a pipeline.</exception>
     public HandlerMiddlewareBuilder Use<TMiddleware>() where TMiddleware : MiddlewareBase<HandleMessageContext, bool>
     {
-        _middlewares.Add(() => ServiceResolver.ResolveService<TMiddleware>());
+        var newMiddleware = ServiceResolver.ResolveService<TMiddleware>();
+        if (newMiddleware.HasNext)
+        {
+            throw new InvalidOperationException(
+                @"Middlewares must be registered into your DI container such that each resolution creates a new instance.
+For StructureMap use Transient(), and for Microsoft.Extensions.DependencyInjection, use AddTransient().
+Please check the documentation for your container for more details.");
+        }
+
+        _middlewares.Add(() => newMiddleware);
         return this;
     }
 
@@ -140,4 +150,4 @@ public HandleMessageMiddleware Build()
 
         return MiddlewareBuilder.BuildAsync(middlewares.ToArray());
     }
-}
+}

src/JustSaying/Messaging/Middleware/MiddlewareBase`2.cs

@@ -10,6 +10,8 @@ public MiddlewareBase<TContext, TOut> WithNext(MiddlewareBase<TContext, TOut> ne
         return this;
     }
 
+    internal bool HasNext => _next != null;
+
     public async Task<TOut> RunAsync(
         TContext context,
         Func<CancellationToken, Task<TOut>> func,
@@ -51,4 +53,4 @@ internal IEnumerable<string> Interrogate()
             yield return middlewareName;
         }
     }
-}
+}

tests/JustSaying.IntegrationTests/Fluent/Subscribing/WhenSubscribingToMultipleTopics.cs

@@ -0,0 +1,47 @@
+using System.Threading.Tasks;
+using JustSaying.Messaging.MessageHandling;
+using JustSaying.TestingFramework;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Xunit.Abstractions;
+
+namespace JustSaying.IntegrationTests.Fluent.Subscribing;
+
+public class WhenSubscribingToMultipleTopics : IntegrationTestBase
+{
+    public WhenSubscribingToMultipleTopics(ITestOutputHelper outputHelper) : base(outputHelper)
+    { }
+
+    [AwsFact]
+    public async Task Then_Both_Handlers_Receive_Messages()
+    {
+        // Arrange
+        var genericHandler = new InspectableHandler<GenericMessage<SimpleMessage>>();
+        var nonGenericHandler = new InspectableHandler<SimpleMessage>();
+
+        var services = GivenJustSaying()
+            .ConfigureJustSaying((builder) => builder.WithLoopbackTopic<GenericMessage<SimpleMessage>>($"{UniqueName}-generic"))
+            .ConfigureJustSaying((builder) => builder.WithLoopbackTopic<SimpleMessage>($"{UniqueName}-nongeneric"))
+            .AddSingleton<IHandlerAsync<GenericMessage<SimpleMessage>>>(genericHandler)
+            .AddSingleton<IHandlerAsync<SimpleMessage>>(nonGenericHandler);
+
+        await WhenAsync(
+            services,
+            async (publisher, listener, serviceProvider, cancellationToken) =>
+            {
+                await listener.StartAsync(cancellationToken);
+                await publisher.StartAsync(cancellationToken);
+
+                // Act
+                await publisher.PublishAsync(new GenericMessage<SimpleMessage>(), cancellationToken);
+                await publisher.PublishAsync(new SimpleMessage(), cancellationToken);
+
+                await Patiently.AssertThatAsync(OutputHelper,
+                    () =>
+                    {
+                        genericHandler.ReceivedMessages.ShouldHaveSingleItem();
+                        nonGenericHandler.ReceivedMessages.ShouldHaveSingleItem();
+                    });
+            });
+    }
+}