Short circuit benchmark

Author: ejsmith

.github/scripts/Update-BenchmarkDocs.ps1

@@ -169,9 +169,9 @@ CreateOrder returns an Order and publishes OrderCreatedEvent to 2 handlers. Foun
 
 $(Build-Table $groups['CascadingMessages'])
 
-### Short-Circuit Middleware (Foundatio Only)
+### Short-Circuit Middleware
 
-Middleware returns cached result; handler is never invoked. Useful for caching or authorization.
+Middleware returns cached result; handler is never invoked. Each library uses its idiomatic short-circuit approach (IPipelineBehavior, HandlerResult.ShortCircuit, HandlerContinuation.Stop, etc.).
 
 $(Build-Table $groups['ShortCircuit'])
 

benchmarks/Foundatio.Mediator.Benchmarks/CoreBenchmarks.cs

@@ -36,7 +36,7 @@ public class CoreBenchmarks
     private readonly PingCommand _pingCommand = new("test-123");
     private readonly GetOrder _getOrder = new(42);
     private readonly GetOrderWithDependencies _getOrderWithDependencies = new(42);
-    private readonly GetOrderShortCircuit _getOrderShortCircuit = new(42);
+    private readonly GetCachedOrder _getCachedOrder = new(42);
     private readonly UserRegisteredEvent _userRegisteredEvent = new("User-456", "test@example.com");
     private readonly CreateOrder _createOrder = new(123, 99.99m);
 
@@ -46,6 +46,7 @@ public class CoreBenchmarks
     private readonly MediatorNetGetOrderWithDependencies _mediatorNetGetOrderWithDependencies = new(42);
     private readonly MediatorNetUserRegisteredEvent _mediatorNetUserRegisteredEvent = new("User-456", "test@example.com");
     private readonly MediatorNetCreateOrder _mediatorNetCreateOrder = new(123, 99.99m);
+    private readonly MediatorNetGetCachedOrder _mediatorNetGetCachedOrder = new(42);
 
     [GlobalSetup]
     public void Setup()
@@ -69,6 +70,8 @@ public void Setup()
             cfg.RegisterServicesFromAssemblyContaining<CoreBenchmarks>();
             // Register timing behavior for GetOrderWithDependencies to match Foundatio's middleware
             cfg.AddBehavior<MediatR.IPipelineBehavior<GetOrderWithDependencies, Order>, Handlers.MediatR.TimingBehavior<GetOrderWithDependencies, Order>>();
+            // Register short-circuit behavior for GetCachedOrder
+            cfg.AddBehavior<MediatR.IPipelineBehavior<GetCachedOrder, Order>, Handlers.MediatR.ShortCircuitBehavior>();
             // Use parallel notification publisher to match Foundatio/MassTransit behavior
             cfg.NotificationPublisher = new MediatR.NotificationPublishers.TaskWhenAllPublisher();
         });
@@ -88,13 +91,16 @@ public void Setup()
             cfg.AddConsumer<Handlers.MassTransit.MassTransitCreateOrderConsumer>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitOrderCreatedConsumer1>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitOrderCreatedConsumer2>();
+            cfg.AddConsumer<Handlers.MassTransit.MassTransitShortCircuitConsumer>();
         });
         _masstransitServices = masstransitServices.BuildServiceProvider();
         _masstransitMediator = _masstransitServices.GetRequiredService<MassTransit.Mediator.IMediator>();
 
         // Setup Mediator.SourceGenerator (MediatorNet)
         var mediatorNetServices = new ServiceCollection();
         mediatorNetServices.AddSingleton<IOrderService, OrderService>();
+        // Register short-circuit behavior before AddMediator so it's available in the pipeline
+        mediatorNetServices.AddSingleton<MediatorLib.IPipelineBehavior<MediatorNetGetCachedOrder, Order>, MediatorNetShortCircuitBehavior>();
         mediatorNetServices.AddMediator(options =>
         {
             options.ServiceLifetime = ServiceLifetime.Singleton;
@@ -119,7 +125,10 @@ public void Setup()
                     .IncludeType<Handlers.Wolverine.WolverineQueryWithDependenciesHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineCreateOrderHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineOrderCreatedHandler1>()
-                    .IncludeType<Handlers.Wolverine.WolverineOrderCreatedHandler2>();
+                    .IncludeType<Handlers.Wolverine.WolverineOrderCreatedHandler2>()
+                    .IncludeType<Handlers.Wolverine.WolverineShortCircuitHandler>();
+                // Register short-circuit middleware for GetCachedOrder
+                opts.Policies.ForMessagesOfType<GetCachedOrder>().AddMiddleware(typeof(Handlers.Wolverine.WolverineShortCircuitMiddleware));
             })
             .Build();
         _wolverineHost.Start();
@@ -329,11 +338,37 @@ public async Task<Order> MediatorNet_CascadingMessages()
         return await _mediatorNetMediator.Send(_mediatorNetCreateOrder);
     }
 
-    // Scenario 6: Short-circuit middleware - Foundatio-only feature
-    // Middleware returns cached result, handler is never invoked
+    // Scenario 6: Short-circuit middleware - returns cached result, handler is never invoked
+    // Tests the cost of short-circuiting via middleware (caching, validation, auth, etc.)
     [Benchmark]
     public async Task<Order> Foundatio_ShortCircuit()
     {
-        return await _foundatioMediator.InvokeAsync<Order>(_getOrderShortCircuit);
+        return await _foundatioMediator.InvokeAsync<Order>(_getCachedOrder);
+    }
+
+    [Benchmark]
+    public async Task<Order> MediatR_ShortCircuit()
+    {
+        return await _mediatrMediator.Send(_getCachedOrder);
+    }
+
+    [Benchmark]
+    public async Task<Order> MassTransit_ShortCircuit()
+    {
+        var client = _masstransitMediator.CreateRequestClient<GetCachedOrder>();
+        var response = await client.GetResponse<Order>(_getCachedOrder);
+        return response.Message;
+    }
+
+    [Benchmark]
+    public async Task<Order?> Wolverine_ShortCircuit()
+    {
+        return await _wolverineBus.InvokeAsync<Order>(_getCachedOrder);
+    }
+
+    [Benchmark]
+    public async Task<Order> MediatorNet_ShortCircuit()
+    {
+        return await _mediatorNetMediator.Send(_mediatorNetGetCachedOrder);
     }
 }

benchmarks/Foundatio.Mediator.Benchmarks/Handlers/Foundatio/FoundatioHandlers.cs

@@ -91,7 +91,7 @@ public async Task HandleAsync(OrderCreatedEvent notification, CancellationToken
 // Scenario 6: Short-circuit handler (never actually called due to ShortCircuitMiddleware)
 public class FoundatioShortCircuitHandler
 {
-    public Task<Order> HandleAsync(GetOrderShortCircuit query, CancellationToken cancellationToken = default)
+    public Task<Order> HandleAsync(GetCachedOrder query, CancellationToken cancellationToken = default)
     {
         // This should never be called - middleware short-circuits before reaching handler
         throw new InvalidOperationException("Short-circuit middleware should have prevented this call");

benchmarks/Foundatio.Mediator.Benchmarks/Handlers/MassTransit/MassTransitHandlers.cs

@@ -89,3 +89,17 @@ public async Task Consume(ConsumeContext<OrderCreatedEvent> context)
         await Task.CompletedTask;
     }
 }
+
+// Scenario 6: Short-circuit handler - MassTransit doesn't have separate middleware for in-memory mediator,
+// so we simulate short-circuit by returning cached value immediately in the consumer.
+// Note: In real MassTransit usage with transport, you'd use a filter to short-circuit.
+public class MassTransitShortCircuitConsumer : IConsumer<GetCachedOrder>
+{
+    private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
+
+    public async Task Consume(ConsumeContext<GetCachedOrder> context)
+    {
+        // Immediately respond with cached value - simulates cache hit
+        await context.RespondAsync(_cachedOrder);
+    }
+}

benchmarks/Foundatio.Mediator.Benchmarks/Handlers/MediatR/MediatRHandlers.cs

@@ -123,3 +123,27 @@ public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TRe
         }
     }
 }
+
+// Scenario 6: Short-circuit handler - MediatR uses IPipelineBehavior to short-circuit
+[FoundatioIgnore]
+public class MediatRShortCircuitHandler : IRequestHandler<GetCachedOrder, Order>
+{
+    public Task<Order> Handle(GetCachedOrder request, CancellationToken cancellationToken)
+    {
+        // This should never be called - pipeline behavior short-circuits before reaching handler
+        throw new InvalidOperationException("Short-circuit behavior should have prevented this call");
+    }
+}
+
+// MediatR short-circuit behavior - returns cached value without calling handler
+[FoundatioIgnore]
+public class ShortCircuitBehavior : IPipelineBehavior<GetCachedOrder, Order>
+{
+    private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
+
+    public Task<Order> Handle(GetCachedOrder request, RequestHandlerDelegate<Order> next, CancellationToken cancellationToken)
+    {
+        // Short-circuit by returning cached value - never calls next()
+        return Task.FromResult(_cachedOrder);
+    }
+}

benchmarks/Foundatio.Mediator.Benchmarks/Handlers/MediatorNet/MediatorNetHandlers.cs

@@ -24,6 +24,9 @@ public record MediatorNetCreateOrder(int CustomerId, decimal Amount) : MediatorL
 [FoundatioIgnore]
 public record MediatorNetOrderCreatedEvent(int OrderId, int CustomerId) : MediatorLib.INotification;
 
+[FoundatioIgnore]
+public record MediatorNetGetCachedOrder(int Id) : MediatorLib.IQuery<Order>;
+
 // Scenario 1: Command handler (InvokeAsync without response)
 [FoundatioIgnore]
 public class MediatorNetCommandHandler : MediatorLib.ICommandHandler<MediatorNetPingCommand>
@@ -122,3 +125,27 @@ public ValueTask Handle(MediatorNetOrderCreatedEvent notification, CancellationT
         return ValueTask.CompletedTask;
     }
 }
+
+// Scenario 6: Short-circuit handler - MediatorNet uses IPipelineBehavior to short-circuit
+[FoundatioIgnore]
+public class MediatorNetShortCircuitHandler : MediatorLib.IQueryHandler<MediatorNetGetCachedOrder, Order>
+{
+    public ValueTask<Order> Handle(MediatorNetGetCachedOrder query, CancellationToken cancellationToken)
+    {
+        // This should never be called - pipeline behavior short-circuits before reaching handler
+        throw new InvalidOperationException("Short-circuit behavior should have prevented this call");
+    }
+}
+
+// MediatorNet short-circuit behavior - returns cached value without calling handler
+[FoundatioIgnore]
+public class MediatorNetShortCircuitBehavior : MediatorLib.IPipelineBehavior<MediatorNetGetCachedOrder, Order>
+{
+    private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
+
+    public ValueTask<Order> Handle(MediatorNetGetCachedOrder message, MediatorLib.MessageHandlerDelegate<MediatorNetGetCachedOrder, Order> next, CancellationToken cancellationToken)
+    {
+        // Short-circuit by returning cached value - never calls next()
+        return ValueTask.FromResult(_cachedOrder);
+    }
+}

benchmarks/Foundatio.Mediator.Benchmarks/Handlers/Wolverine/WolverineHandlers.cs

@@ -87,3 +87,28 @@ public Task Handle(OrderCreatedEvent notification)
         return Task.CompletedTask;
     }
 }
+
+// Scenario 6: Short-circuit - Wolverine uses Before middleware with HandlerContinuation.Stop
+[FoundatioIgnore]
+public class WolverineShortCircuitHandler
+{
+    public Task<Order> Handle(GetCachedOrder query)
+    {
+        // This should never be called - middleware short-circuits before reaching handler
+        throw new InvalidOperationException("Short-circuit middleware should have prevented this call");
+    }
+}
+
+// Wolverine short-circuit middleware - uses HandlerContinuation to stop processing
+[FoundatioIgnore]
+public class WolverineShortCircuitMiddleware
+{
+    private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
+
+    // Wolverine Before method with tuple return for short-circuit
+    public static (HandlerContinuation, Order) Before(GetCachedOrder message)
+    {
+        // Short-circuit by returning Stop with the cached value
+        return (HandlerContinuation.Stop, _cachedOrder);
+    }
+}

benchmarks/Foundatio.Mediator.Benchmarks/Messages/BenchmarkMessages.cs

@@ -19,5 +19,11 @@ public record UserRegisteredEvent(string UserId, string Email) : MediatR.INotifi
 public record CreateOrder(int CustomerId, decimal Amount) : IRequest<Order>;
 public record OrderCreatedEvent(int OrderId, int CustomerId) : MediatR.INotification;
 
-// Scenario 6: Short-circuit middleware (cache hit simulation) - Foundatio only
-public record GetOrderShortCircuit(int Id);
+// Scenario 6: Short-circuit / Cache-hit - tests middleware that returns early without calling handler
+// Each library implements this with their idiomatic approach:
+// - Foundatio: HandlerResult.ShortCircuit(value) in middleware
+// - MediatR: IPipelineBehavior returns cached value directly
+// - Wolverine: HandlerContinuation.Stop with cached value
+// - MediatorNet: IPipelineBehavior returns cached value directly
+// - MassTransit: Filter returns without calling next.Send()
+public record GetCachedOrder(int Id) : IRequest<Order>;

benchmarks/Foundatio.Mediator.Benchmarks/Middleware/BenchmarkMiddleware.cs

@@ -25,13 +25,13 @@ public void Finally(GetOrderWithDependencies message, Stopwatch? stopwatch, Hand
 
 /// <summary>
 /// Short-circuit middleware that immediately returns a cached result without calling the handler.
-/// This demonstrates Foundatio's unique short-circuit capability.
+/// This demonstrates middleware returning early (cache hit, validation success with cached result, etc.)
 /// </summary>
 public class ShortCircuitMiddleware
 {
     private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
 
-    public HandlerResult Before(GetOrderShortCircuit message)
+    public HandlerResult Before(GetCachedOrder message)
     {
         // Always short-circuit with cached result - simulates cache hit scenario
         return HandlerResult.ShortCircuit(_cachedOrder);