Add wolverine as a comparison library

Author: ejsmith

.github/scripts/Update-BenchmarkDocs.ps1

@@ -68,7 +68,7 @@ $groups = @{
 }
 
 # Define the order of implementations
-$implOrder = @('Direct', 'Foundatio', 'MediatR', 'MassTransit')
+$implOrder = @('Direct', 'Foundatio', 'MediatR', 'Wolverine', 'MassTransit')
 
 foreach ($row in $csv) {
     $method = $row.Method
@@ -84,7 +84,8 @@ foreach ($row in $csv) {
 }
 
 # Sort each group by implementation order
-foreach ($key in $groups.Keys) {
+$groupKeys = @($groups.Keys)
+foreach ($key in $groupKeys) {
     $groups[$key] = $groups[$key] | Sort-Object {
         $method = $_.Method
         for ($i = 0; $i -lt $implOrder.Count; $i++) {

.github/workflows/benchmarks.yml

@@ -52,7 +52,7 @@ jobs:
 
         git add docs/guide/performance.md
         git commit -m "📊 Update benchmark results [skip ci]"
-        
+
         # Pull with rebase in case changes were pushed while benchmarks ran
         git pull --rebase origin main
         git push

benchmarks/Foundatio.Mediator.Benchmarks/CoreBenchmarks.cs

@@ -3,7 +3,10 @@
 using Foundatio.Mediator.Benchmarks.Handlers.Foundatio;
 using Foundatio.Mediator.Benchmarks.Services;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using MassTransit;
+using Wolverine;
 
 namespace Foundatio.Mediator.Benchmarks;
 
@@ -14,9 +17,11 @@ public class CoreBenchmarks
     private IServiceProvider _foundatioServices = null!;
     private IServiceProvider _mediatrServices = null!;
     private IServiceProvider _masstransitServices = null!;
+    private IHost _wolverineHost = null!;
     private Foundatio.Mediator.IMediator _foundatioMediator = null!;
     private MediatR.IMediator _mediatrMediator = null!;
     private MassTransit.Mediator.IMediator _masstransitMediator = null!;
+    private IMessageBus _wolverineBus = null!;
 
     // Direct handler instances for baseline comparison
     private readonly FoundatioCommandHandler _directCommandHandler = new();
@@ -65,6 +70,18 @@ public void Setup()
         });
         _masstransitServices = masstransitServices.BuildServiceProvider();
         _masstransitMediator = _masstransitServices.GetRequiredService<MassTransit.Mediator.IMediator>();
+
+        // Setup Wolverine
+        _wolverineHost = Host.CreateDefaultBuilder()
+            .ConfigureLogging(logging => logging.ClearProviders())
+            .UseWolverine(opts =>
+            {
+                opts.Services.AddSingleton<IOrderService, OrderService>();
+                opts.Discovery.IncludeAssembly(typeof(CoreBenchmarks).Assembly);
+            })
+            .Build();
+        _wolverineHost.Start();
+        _wolverineBus = _wolverineHost.Services.GetRequiredService<IMessageBus>();
     }
 
     [GlobalCleanup]
@@ -77,6 +94,9 @@ public async Task Cleanup()
             await asyncDisposable.DisposeAsync();
         else
             (_masstransitServices as IDisposable)?.Dispose();
+
+        await _wolverineHost.StopAsync();
+        _wolverineHost.Dispose();
     }
 
     // Baseline: Direct method calls (no mediator overhead)
@@ -123,6 +143,12 @@ public async Task MassTransit_Command()
         await _masstransitMediator.Send(_pingCommand);
     }
 
+    [Benchmark]
+    public async Task Wolverine_Command()
+    {
+        await _wolverineBus.InvokeAsync(_pingCommand);
+    }
+
     // Scenario 2: InvokeAsync<T> (Query)
     [Benchmark]
     public async Task<Order> Foundatio_Query()
@@ -144,6 +170,12 @@ public async Task<Order> MassTransit_Query()
         return response.Message;
     }
 
+    [Benchmark]
+    public async Task<Order?> Wolverine_Query()
+    {
+        return await _wolverineBus.InvokeAsync<Order>(_getOrder);
+    }
+
     // Scenario 3: PublishAsync with a single handler
     [Benchmark]
     public async Task Foundatio_Publish()
@@ -163,6 +195,12 @@ public async Task MassTransit_Publish()
         await _masstransitMediator.Publish(_userRegisteredEvent);
     }
 
+    [Benchmark]
+    public async Task Wolverine_Publish()
+    {
+        await _wolverineBus.PublishAsync(_userRegisteredEvent);
+    }
+
     // Scenario 4: InvokeAsync<T> with DI (Query with dependency injection)
     [Benchmark]
     public async Task<Order> Foundatio_QueryWithDependencies()
@@ -183,4 +221,10 @@ public async Task<Order> MassTransit_QueryWithDependencies()
         var response = await client.GetResponse<Order>(_getOrderWithDependencies);
         return response.Message;
     }
+
+    [Benchmark]
+    public async Task<Order?> Wolverine_QueryWithDependencies()
+    {
+        return await _wolverineBus.InvokeAsync<Order>(_getOrderWithDependencies);
+    }
 }

benchmarks/Foundatio.Mediator.Benchmarks/Foundatio.Mediator.Benchmarks.csproj

@@ -7,6 +7,8 @@
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <PublishAot>false</PublishAot>
+    <!-- Suppress NuGet warnings for version constraint overrides (Wolverine doesn't support .NET 10 yet) -->
+    <NoWarn>$(NoWarn);NU1608;NU1603</NoWarn>
     <!-- Emit compiler generated files for debugging purposes -->
     <CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
@@ -39,8 +41,14 @@
     <PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageReference Include="MassTransit" Version="8.5.7" />
     <PackageReference Include="MediatR" Version="12.4.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="10.0.0" />
+    <PackageReference Include="WolverineFx" Version="3.9.0" />
   </ItemGroup>
 
 </Project>

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

@@ -0,0 +1,46 @@
+using Foundatio.Mediator.Benchmarks.Messages;
+using Foundatio.Mediator.Benchmarks.Services;
+
+namespace Foundatio.Mediator.Benchmarks.Handlers.Wolverine;
+
+// Scenario 1: Command handler (InvokeAsync without response)
+[FoundatioIgnore]
+public class WolverineCommandHandler
+{
+    public Task Handle(PingCommand command)
+    {
+        // Simulate minimal work
+        return Task.CompletedTask;
+    }
+}
+
+// Scenario 2: Query handler (InvokeAsync<T>) - No DI for baseline comparison
+[FoundatioIgnore]
+public class WolverineQueryHandler
+{
+    public Task<Order> Handle(GetOrder query)
+    {
+        return Task.FromResult(new Order(query.Id, 99.99m, DateTime.UtcNow));
+    }
+}
+
+// Scenario 3: Single event handler (PublishAsync with single handler)
+[FoundatioIgnore]
+public class WolverineEventHandler
+{
+    public Task Handle(UserRegisteredEvent notification)
+    {
+        // Simulate minimal event handling work
+        return Task.CompletedTask;
+    }
+}
+
+// Scenario 4: Query handler with dependency injection
+[FoundatioIgnore]
+public class WolverineQueryWithDependenciesHandler
+{
+    public Task<Order> Handle(GetOrderWithDependencies query, IOrderService orderService)
+    {
+        return orderService.GetOrderAsync(query.Id);
+    }
+}