Performance Testing — Benchmarks & Load Tests

Core Principles

• BenchmarkDotNet for micro-benchmarks of hot path code
• Test.Live projects for Service Bus throughput validation with real infrastructure
• Establish baselines before optimization
• Focus on hot paths: serialization, event handling, query execution
• Load testing validates system behavior under stress
• Performance tests run separately from CI (manual or scheduled)

Key Patterns

BenchmarkDotNet Setup

namespace {Company}.{Domain}.Benchmarks;

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net90)]
public class EventSerializationBenchmarks
{
    private Event<OrderCreatedData> _event = null!;
    private string _json = null!;

    [GlobalSetup]
    public void Setup()
    {
        _event = new Event<OrderCreatedData>
        {
            AggregateId = Guid.NewGuid(),
            Sequence = 1,
            Type = EventTypes.OrderCreated,
            DateTime = DateTime.UtcNow,
            Data = new OrderCreatedData("Test", 100m, [])
        };
        _json = JsonConvert.SerializeObject(_event);
    }

    [Benchmark(Baseline = true)]
    public string Serialize_Newtonsoft()
        => JsonConvert.SerializeObject(_event);

    [Benchmark]
    public Event<OrderCreatedData> Deserialize_Newtonsoft()
        => JsonConvert.DeserializeObject<Event<OrderCreatedData>>(_json)!;
}

// Run: dotnet run -c Release --project src/Benchmarks/

Test.Live Project (Service Bus Throughput)

namespace {Company}.{Domain}.Tests.Live;

/// <summary>
/// Sends batches of events to Service Bus and measures throughput.
/// Requires real Service Bus connection string in environment.
/// </summary>
public sealed class ServiceBusThroughputTest
{
    [Fact(Skip = "Manual execution only — requires live Service Bus")]
    public async Task MeasurePublishThroughput()
    {
        // Arrange
        var connectionString = Environment.GetEnvironmentVariable(
            "SERVICEBUS_CONNECTION_STRING")!;
        var client = new ServiceBusClient(connectionString);
        var sender = client.CreateSender("{company}-{domain}-commands");

        var events = Enumerable.Range(1, 1000).Select(i =>
            new ServiceBusMessage($"{{\"AggregateId\":\"{Guid.NewGuid()}\",\"Sequence\":{i}}}")
            {
                Subject = EventTypes.OrderCreated,
                SessionId = Guid.NewGuid().ToString()
            }).ToList();

        // Act
        var sw = Stopwatch.StartNew();

        foreach (var batch in events.Chunk(100))
        {
            using var messageBatch = await sender.CreateMessageBatchAsync();
            foreach (var msg in batch)
                messageBatch.TryAddMessage(msg);
            await sender.SendMessagesAsync(messageBatch);
        }

        sw.Stop();

        // Assert
        var throughput = events.Count / sw.Elapsed.TotalSeconds;
        Console.WriteLine($"Throughput: {throughput:F0} messages/sec");
        throughput.Should().BeGreaterThan(100, "Minimum throughput not met");
    }
}

Query Performance Test

[MemoryDiagnoser]
public class QueryBenchmarks
{
    private ApplicationDbContext _db = null!;

    [GlobalSetup]
    public async Task Setup()
    {
        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
            .UseSqlServer("Server=.;Database=BenchmarkDb;Trusted_Connection=true;")
            .Options;
        _db = new ApplicationDbContext(options);

        // Seed 10,000 orders for realistic benchmarks
        await SeedData.SeedOrders(_db, 10000);
    }

    [Benchmark]
    public async Task<List<OrderOutput>> Query_WithPagination()
    {
        return await _db.Orders.AsNoTracking()
            .OrderByDescending(o => o.Sequence)
            .Skip(0).Take(20)
            .Select(o => new OrderOutput(o.Id, o.CustomerName, o.Total))
            .ToListAsync();
    }

    [Benchmark]
    public async Task<List<OrderOutput>> Query_WithFilter()
    {
        return await _db.Orders.AsNoTracking()
            .Where(o => o.CustomerName.Contains("Test"))
            .OrderByDescending(o => o.Sequence)
            .Skip(0).Take(20)
            .Select(o => new OrderOutput(o.Id, o.CustomerName, o.Total))
            .ToListAsync();
    }
}

Project Structure

tests/
  {Domain}.Tests.Unit/          # Unit tests (CI)
  {Domain}.Tests.Integration/   # Integration tests (CI)
  {Domain}.Tests.Live/          # Live infrastructure tests (manual)
  {Domain}.Benchmarks/          # BenchmarkDotNet projects (manual)

Anti-Patterns

Anti-Pattern	Correct Approach
Optimizing without benchmarks	Measure first, optimize second
Benchmarks in CI pipeline	Run benchmarks manually or on schedule
Testing with Debug build	Always benchmark in Release mode
Live tests without Skip attribute	Mark with Skip to prevent accidental CI runs

Detect Existing Patterns

# Find BenchmarkDotNet usage
grep -r "BenchmarkDotNet\|\[Benchmark\]" --include="*.cs" tests/ benchmarks/

# Find Test.Live projects
find . -name "*Tests.Live*" -type d

# Find throughput tests
grep -r "Throughput\|Stopwatch" --include="*.cs" tests/

Adding to Existing Project

1. Check for existing benchmark projects before creating new ones
2. Add benchmarks in Benchmarks/ project with Release configuration
3. Use Test.Live project for real infrastructure validation
4. Mark live tests with Skip attribute or [Trait("Category", "Live")]
5. Establish baselines before making performance changes