Add fast path for non-DI scenarios

Author: ejsmith

.github/scripts/Update-BenchmarkDocs.ps1

@@ -89,16 +89,28 @@ foreach ($row in $csv) {
     }
 }
 
-# Sort each group by implementation order
-$groupKeys = @($groups.Keys)
-foreach ($key in $groupKeys) {
-    $groups[$key] = $groups[$key] | Sort-Object {
-        $method = $_.Method
-        for ($i = 0; $i -lt $implOrder.Count; $i++) {
-            if ($method -match "^$($implOrder[$i])_") { return $i }
+# Helper function to parse Mean value to nanoseconds for sorting
+function Parse-MeanToNs {
+    param([string]$Value)
+    if ($Value -match '^([\d,.]+)\s*(ns|us|μs|ms|s)$') {
+        $num = [double]($Matches[1] -replace ',', '')
+        $unit = $Matches[2]
+        switch ($unit) {
+            'ns' { return $num }
+            'us' { return $num * 1000 }
+            'μs' { return $num * 1000 }
+            'ms' { return $num * 1000000 }
+            's'  { return $num * 1000000000 }
+            default { return $num }
         }
-        return 999
     }
+    return [double]::MaxValue
+}
+
+# Sort each group by Mean (best performance first)
+$groupKeys = @($groups.Keys)
+foreach ($key in $groupKeys) {
+    $groups[$key] = $groups[$key] | Sort-Object { Parse-MeanToNs $_.Mean }
 }
 
 # Helper function to format allocated bytes with thousand separators

.github/workflows/benchmarks.yml

@@ -2,15 +2,6 @@ name: Benchmarks
 
 on:
   workflow_dispatch:
-  schedule:
-    # Run daily at 2:00 AM UTC
-    - cron: '0 2 * * *'
-  push:
-    branches:
-      - main
-    paths:
-      - '.github/scripts/Update-BenchmarkDocs.ps1'
-      - '.github/workflows/benchmarks.yml'
 
 jobs:
   benchmark:

benchmarks/Foundatio.Mediator.Benchmarks/CoreBenchmarks.cs

@@ -31,19 +31,22 @@ public class CoreBenchmarks
     private readonly FoundatioCommandHandler _directCommandHandler = new();
     private readonly FoundatioQueryHandler _directQueryHandler = new();
     private readonly FoundatioEventHandler _directEventHandler = new();
-    private FoundatioQueryWithDependenciesHandler _directQueryWithDependenciesHandler = null!;
+    private readonly FoundatioCreateOrderHandler _directCreateOrderHandler = new();
+    private readonly FoundatioOrderCreatedHandler1 _directOrderCreatedHandler1 = new();
+    private readonly FoundatioOrderCreatedHandler2 _directOrderCreatedHandler2 = new();
+    private FoundatioFullQueryHandler _directFullQueryHandler = null!;
 
     private readonly PingCommand _pingCommand = new("test-123");
     private readonly GetOrder _getOrder = new(42);
-    private readonly GetOrderWithDependencies _getOrderWithDependencies = new(42);
+    private readonly GetFullQuery _getFullQuery = 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);
 
     // MediatorNet-specific message types (uses different interfaces)
     private readonly MediatorNetPingCommand _mediatorNetPingCommand = new("test-123");
     private readonly MediatorNetGetOrder _mediatorNetGetOrder = new(42);
-    private readonly MediatorNetGetOrderWithDependencies _mediatorNetGetOrderWithDependencies = new(42);
+    private readonly MediatorNetGetFullQuery _mediatorNetGetFullQuery = 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);
@@ -58,8 +61,8 @@ public void Setup()
         _foundatioServices = foundatioServices.BuildServiceProvider();
         _foundatioMediator = _foundatioServices.GetRequiredService<Foundatio.Mediator.IMediator>();
 
-        // Create direct handler with DI
-        _directQueryWithDependenciesHandler = new FoundatioQueryWithDependenciesHandler(
+        // Create direct handler with DI for FullQuery baseline
+        _directFullQueryHandler = new FoundatioFullQueryHandler(
             _foundatioServices.GetRequiredService<IOrderService>());
 
         // Setup MediatR
@@ -68,8 +71,8 @@ public void Setup()
         mediatrServices.AddMediatR(cfg =>
         {
             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 timing behavior for GetFullQuery to match Foundatio's middleware
+            cfg.AddBehavior<MediatR.IPipelineBehavior<GetFullQuery, Order>, Handlers.MediatR.TimingBehavior<GetFullQuery, 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
@@ -87,7 +90,7 @@ public void Setup()
             cfg.AddConsumer<Handlers.MassTransit.MassTransitQueryConsumer>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitEventConsumer>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitEventConsumer2>();
-            cfg.AddConsumer<Handlers.MassTransit.MassTransitQueryWithDependenciesConsumer>();
+            cfg.AddConsumer<Handlers.MassTransit.MassTransitFullQueryConsumer>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitCreateOrderConsumer>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitOrderCreatedConsumer1>();
             cfg.AddConsumer<Handlers.MassTransit.MassTransitOrderCreatedConsumer2>();
@@ -122,7 +125,7 @@ public void Setup()
                     .IncludeType<Handlers.Wolverine.WolverineQueryHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineEventHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineEventHandler2>()
-                    .IncludeType<Handlers.Wolverine.WolverineQueryWithDependenciesHandler>()
+                    .IncludeType<Handlers.Wolverine.WolverineFullQueryHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineCreateOrderHandler>()
                     .IncludeType<Handlers.Wolverine.WolverineOrderCreatedHandler1>()
                     .IncludeType<Handlers.Wolverine.WolverineOrderCreatedHandler2>()
@@ -166,16 +169,11 @@ public async Task<Order> Direct_Query()
     }
 
     [Benchmark]
-    public async Task Direct_Event()
+    public async Task Direct_Publish()
     {
         await _directEventHandler.HandleAsync(_userRegisteredEvent);
     }
 
-    [Benchmark]
-    public async Task<Order> Direct_QueryWithDependencies()
-    {
-        return await _directQueryWithDependenciesHandler.HandleAsync(_getOrderWithDependencies);
-    }
 
     // Scenario 1: InvokeAsync without response (Command)
     [Benchmark]
@@ -272,40 +270,65 @@ public async Task MediatorNet_Publish()
         await _mediatorNetMediator.Publish(_mediatorNetUserRegisteredEvent);
     }
 
-    // Scenario 4: InvokeAsync<T> with DI (Query with dependency injection)
+    // Scenario 4: InvokeAsync<T> with DI (Query with dependency injection and middleware)
+    [Benchmark]
+    public async Task<Order> Direct_FullQuery()
+    {
+        // Simulate TimingMiddleware.Before
+        var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+        try
+        {
+            return await _directFullQueryHandler.HandleAsync(_getFullQuery);
+        }
+        finally
+        {
+            // Simulate TimingMiddleware.Finally
+            stopwatch.Stop();
+        }
+    }
+
     [Benchmark]
     public async Task<Order> Foundatio_FullQuery()
     {
-        return await _foundatioMediator.InvokeAsync<Order>(_getOrderWithDependencies);
+        return await _foundatioMediator.InvokeAsync<Order>(_getFullQuery);
     }
 
     [Benchmark]
     public async Task<Order> MediatR_FullQuery()
     {
-        return await _mediatrMediator.Send(_getOrderWithDependencies);
+        return await _mediatrMediator.Send(_getFullQuery);
     }
 
     [Benchmark]
     public async Task<Order> MassTransit_FullQuery()
     {
-        var client = _masstransitMediator.CreateRequestClient<GetOrderWithDependencies>();
-        var response = await client.GetResponse<Order>(_getOrderWithDependencies);
+        var client = _masstransitMediator.CreateRequestClient<GetFullQuery>();
+        var response = await client.GetResponse<Order>(_getFullQuery);
         return response.Message;
     }
 
     [Benchmark]
     public async Task<Order?> Wolverine_FullQuery()
     {
-        return await _wolverineBus.InvokeAsync<Order>(_getOrderWithDependencies);
+        return await _wolverineBus.InvokeAsync<Order>(_getFullQuery);
     }
 
     [Benchmark]
     public async Task<Order> MediatorNet_FullQuery()
     {
-        return await _mediatorNetMediator.Send(_mediatorNetGetOrderWithDependencies);
+        return await _mediatorNetMediator.Send(_mediatorNetGetFullQuery);
     }
 
     // Scenario 5: Cascading messages - invoke returns result and auto-publishes events to multiple handlers
+    [Benchmark]
+    public async Task<Order> Direct_CascadingMessages()
+    {
+        var (order, evt) = await _directCreateOrderHandler.HandleAsync(_createOrder);
+        await _directOrderCreatedHandler1.HandleAsync(evt);
+        await _directOrderCreatedHandler2.HandleAsync(evt);
+        return order;
+    }
+
     [Benchmark]
     public async Task<Order> Foundatio_CascadingMessages()
     {
@@ -340,6 +363,15 @@ public async Task<Order> MediatorNet_CascadingMessages()
 
     // Scenario 6: Short-circuit middleware - returns cached result, handler is never invoked
     // Tests the cost of short-circuiting via middleware (caching, validation, auth, etc.)
+    private static readonly Order _cachedOrder = new(999, 49.99m, DateTime.UtcNow);
+
+    [Benchmark]
+    public Task<Order> Direct_ShortCircuit()
+    {
+        // Simulate ShortCircuitMiddleware.Before returning cached result
+        return Task.FromResult(_cachedOrder);
+    }
+
     [Benchmark]
     public async Task<Order> Foundatio_ShortCircuit()
     {

benchmarks/Foundatio.Mediator.Benchmarks/FoundatioBenchmarks.cs

@@ -18,7 +18,7 @@ public class FoundatioBenchmarks
 
     private readonly PingCommand _pingCommand = new("test-123");
     private readonly GetOrder _getOrder = new(42);
-    private readonly GetOrderWithDependencies _getOrderWithDependencies = new(42);
+    private readonly GetFullQuery _getFullQuery = new(42);
     private readonly UserRegisteredEvent _userRegisteredEvent = new("User-456", "test@example.com");
 
     [GlobalSetup]
@@ -56,8 +56,8 @@ public async Task Publish()
     }
 
     [Benchmark]
-    public async Task<Order> QueryWithDependencies()
+    public async Task<Order> FullQuery()
     {
-        return await _foundatioMediator.InvokeAsync<Order>(_getOrderWithDependencies);
+        return await _foundatioMediator.InvokeAsync<Order>(_getFullQuery);
     }
 }

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

@@ -43,16 +43,16 @@ public async Task HandleAsync(UserRegisteredEvent notification, CancellationToke
 }
 
 // Scenario 4: Query handler with dependency injection
-public class FoundatioQueryWithDependenciesHandler
+public class FoundatioFullQueryHandler
 {
     private readonly IOrderService _orderService;
 
-    public FoundatioQueryWithDependenciesHandler(IOrderService orderService)
+    public FoundatioFullQueryHandler(IOrderService orderService)
     {
         _orderService = orderService;
     }
 
-    public async Task<Order> HandleAsync(GetOrderWithDependencies query, CancellationToken cancellationToken = default)
+    public async Task<Order> HandleAsync(GetFullQuery query, CancellationToken cancellationToken = default)
     {
         return await _orderService.GetOrderAsync(query.Id, cancellationToken);
     }

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

@@ -44,16 +44,16 @@ public async Task Consume(ConsumeContext<UserRegisteredEvent> context)
 }
 
 // Scenario 4: Query handler with dependency injection
-public class MassTransitQueryWithDependenciesConsumer : IConsumer<GetOrderWithDependencies>
+public class MassTransitFullQueryConsumer : IConsumer<GetFullQuery>
 {
     private readonly IOrderService _orderService;
 
-    public MassTransitQueryWithDependenciesConsumer(IOrderService orderService)
+    public MassTransitFullQueryConsumer(IOrderService orderService)
     {
         _orderService = orderService;
     }
 
-    public async Task Consume(ConsumeContext<GetOrderWithDependencies> context)
+    public async Task Consume(ConsumeContext<GetFullQuery> context)
     {
         var order = await _orderService.GetOrderAsync(context.Message.Id);
         await context.RespondAsync(order);

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

@@ -49,16 +49,16 @@ public async Task Handle(UserRegisteredEvent notification, CancellationToken can
 
 // Scenario 4: Query handler with dependency injection
 [FoundatioIgnore]
-public class MediatRQueryWithDependenciesHandler : IRequestHandler<GetOrderWithDependencies, Order>
+public class MediatRFullQueryHandler : IRequestHandler<GetFullQuery, Order>
 {
     private readonly IOrderService _orderService;
 
-    public MediatRQueryWithDependenciesHandler(IOrderService orderService)
+    public MediatRFullQueryHandler(IOrderService orderService)
     {
         _orderService = orderService;
     }
 
-    public async Task<Order> Handle(GetOrderWithDependencies request, CancellationToken cancellationToken)
+    public async Task<Order> Handle(GetFullQuery request, CancellationToken cancellationToken)
     {
         return await _orderService.GetOrderAsync(request.Id, cancellationToken);
     }

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

@@ -13,7 +13,7 @@ public record MediatorNetPingCommand(string Id) : MediatorLib.ICommand;
 public record MediatorNetGetOrder(int Id) : MediatorLib.IQuery<Order>;
 
 [FoundatioIgnore]
-public record MediatorNetGetOrderWithDependencies(int Id) : MediatorLib.IQuery<Order>;
+public record MediatorNetGetFullQuery(int Id) : MediatorLib.IQuery<Order>;
 
 [FoundatioIgnore]
 public record MediatorNetUserRegisteredEvent(string UserId, string Email) : MediatorLib.INotification;
@@ -71,16 +71,16 @@ public ValueTask Handle(MediatorNetUserRegisteredEvent notification, Cancellatio
 
 // Scenario 4: Query handler with dependency injection
 [FoundatioIgnore]
-public class MediatorNetQueryWithDependenciesHandler : MediatorLib.IQueryHandler<MediatorNetGetOrderWithDependencies, Order>
+public class MediatorNetFullQueryHandler : MediatorLib.IQueryHandler<MediatorNetGetFullQuery, Order>
 {
     private readonly IOrderService _orderService;
 
-    public MediatorNetQueryWithDependenciesHandler(IOrderService orderService)
+    public MediatorNetFullQueryHandler(IOrderService orderService)
     {
         _orderService = orderService;
     }
 
-    public async ValueTask<Order> Handle(MediatorNetGetOrderWithDependencies query, CancellationToken cancellationToken)
+    public async ValueTask<Order> Handle(MediatorNetGetFullQuery query, CancellationToken cancellationToken)
     {
         return await _orderService.GetOrderAsync(query.Id, cancellationToken);
     }

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

@@ -48,9 +48,9 @@ public Task Handle(UserRegisteredEvent notification)
 
 // Scenario 4: Query handler with dependency injection
 [FoundatioIgnore]
-public class WolverineQueryWithDependenciesHandler
+public class WolverineFullQueryHandler
 {
-    public Task<Order> Handle(GetOrderWithDependencies query, IOrderService orderService)
+    public Task<Order> Handle(GetFullQuery query, IOrderService orderService)
     {
         return orderService.GetOrderAsync(query.Id);
     }

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

@@ -9,8 +9,8 @@ public record PingCommand(string Id) : IRequest;
 // Scenario 2: Query with return value for InvokeAsync<T>
 public record GetOrder(int Id) : IRequest<Order>;
 
-// Scenario 2b: Query with dependency injection
-public record GetOrderWithDependencies(int Id) : IRequest<Order>;
+// Scenario 4: FullQuery - Query with dependency injection
+public record GetFullQuery(int Id) : IRequest<Order>;
 
 // Scenario 3: Notification for PublishAsync with multiple handlers
 public record UserRegisteredEvent(string UserId, string Email) : MediatR.INotification;