Unit Testing with xUnit

Performance is a feature, and in high-traffic production systems it is often the feature that determines success or failure. A web API that responds in 20ms at the 99th percentile serves 50 times more users than one responding at 1000ms — without any additional infrastructure. .NET Core and ASP.NET Core were engineered with performance as a primary goal, routinely ranking among the top performers in the TechEmpower Framework Benchmarks, a widely-cited, independent benchmark of web framework throughput. Understanding .NET performance optimization techniques allows developers to build systems that serve massive traffic loads on minimal hardware, reducing cloud infrastructure costs while improving user experience. Asynchronous programming is the most impactful performance pattern for I/O-bound web applications. Traditional synchronous code blocks a thread while waiting for database queries, HTTP calls, file reads, or other I/O operations to complete. With typical web servers supporting 1,000–2,000 threads maximum, a synchronous API under load quickly exhausts its thread pool and begins rejecting requests. Asynchronous code using async/await frees the thread during I/O waits, allowing it to handle other requests. A single thread can manage hundreds of concurrent outstanding I/O operations. ASP.NET Core's async controller actions, async middleware, and async EF Core queries make asynchronous programming idiomatic and straightforward. Properly written async .NET Core APIs can handle 10–100x more concurrent users than their synchronous equivalents on identical hardware. Caching reduces latency and database load by storing the results of expensive computations or queries and returning cached results on subsequent requests. IMemoryCache stores data in the application process's heap — fast but non-distributed (each server has its own cache). IDistributedCache with a Redis backend provides a shared cache across all instances of a scaled-out application. Response caching caches entire HTTP responses using the [ResponseCache] attribute or middleware, serving repeated identical requests without executing any application code. Output caching (new in .NET 7) provides fine-grained control over response caching with tag-based invalidation. Cache-aside, write-through, and write-behind are the standard caching patterns for managing the relationship between cache and database. Memory management and garbage collection significantly impact .NET performance under load. The .NET garbage collector (GC) reclaims memory from objects that are no longer referenced, but GC pauses can cause latency spikes. The key to GC-friendly code is minimizing allocations — creating fewer objects means less garbage to collect. Span<T> and Memory<T> allow processing large data buffers (strings, byte arrays, arrays) as slices without copying, eliminating allocation entirely. ArrayPool<T> recycles large arrays. StringBuilder avoids repeated string concatenation allocations. ValueTask<T> avoids heap allocation for commonly synchronous async methods. The .NET 8 Native AOT compilation mode eliminates JIT startup overhead entirely by compiling to native machine code ahead of time.

xUnit is a popular testing framework for .NET that provides a clean and simple API for writing tests.