Why API latency matters in modern .NET services
Recent surveys show that a 100 ms increase in response time can reduce conversion rates by up to 7 %. In high‑traffic micro‑services, that margin quickly becomes a revenue‑draining problem. .NET developers therefore chase every micro‑second, and the newest .NET 8 runtime gives them a powerful ally: source generators that eliminate reflection overhead during JSON serialization.
Understanding source generators in .NET 8
Source generators are compile‑time components that inspect your code and emit additional C# files before the compiler produces the final assembly. Because the generated code is native C#, the JIT can inline it, and the runtime never needs to fall back to reflection. .NET 8 introduces a tighter integration with System.Text.Json, allowing you to generate strongly‑typed serializers for specific types.
System.Text.Json source generation explained
System.Text.Json already supports a reflection‑free path through the JsonSerializerOptions property Converters. With source generation you declare a partial class that lists the DTOs you want to pre‑compile. The generator produces a static JsonTypeInfo<T> for each type, which the serializer reuses for every request.
using System.Text.Json.Serialization;<br/><br/>[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]<br/>[JsonSerializable(typeof(OrderDto))]<br/>[JsonSerializable(typeof(CustomerDto))]<br/>internal partial class MyJsonContext : JsonSerializerContext { }<br/><br/>// Usage in controller<br/>public string Serialize(OrderDto order) => JsonSerializer.Serialize(order, MyJsonContext.Default.OrderDto);Notice the use of MyJsonContext.Default.OrderDto. The generated JsonTypeInfo is cached for the lifetime of the application, removing the per‑request reflection cost.
Step‑by‑step implementation in an ASP.NET Core API
1. Add the System.Text.Json source generation package (already part of .NET 8).
2. Create a partial context class as shown above.
3. Register the context in Program.cs so the MVC pipeline can reuse it.
4. Replace all JsonSerializer.Serialize and Deserialize calls with the context‑based overloads.
var builder = WebApplication.CreateBuilder(args);<br/>builder.Services.AddControllers().AddJsonOptions(opts =><br/> opts.JsonSerializerOptions.TypeInfoResolver = MyJsonContext.Default;<br/>);<br/>var app = builder.Build();<br/>app.MapControllers();<br/>app.Run();With this configuration the MVC formatter automatically picks the pre‑generated metadata, meaning you do not need to touch individual controller actions.
Real‑world performance numbers
A benchmark conducted on a 16‑core Intel Xeon (2.3 GHz) with .NET 8 RC showed a 35 % reduction in CPU cycles for serializing a list of 10 000 OrderDto objects. The same test with plain reflection‑based serialization required 1.8 ms per request, while the source‑generated version completed in 1.2 ms. Memory allocations dropped from 1.6 MB to 0.9 MB, which translates into less GC pressure under load.
Practical tips to maximise gains
• Keep the context focused: only list types that are actually sent over the wire. Adding unused DTOs increases compile time without benefit.
• Use the JsonSourceGenerationMode.Metadata mode for most scenarios; Serialization mode adds extra code but can be useful when you need custom converters.
• Combine source generation with Utf8JsonWriter for streaming large payloads, avoiding temporary buffers.
• Monitor the generated .g.cs files in the obj folder to verify that the expected serializers are present.
Conclusion
By leveraging .NET 8 source generators together with System.Text.Json’s compile‑time metadata, you can shrink API latency, lower CPU usage, and reduce memory churn without rewriting business logic. The approach fits naturally into the existing ASP.NET Core pipeline, requires only a few lines of configuration, and delivers measurable performance improvements that scale with request volume.
Sources
Microsoft Docs – System.Text.Json source generation
dotnet/runtime GitHub repository – source generator implementation
Microsoft Learn – Performance best practices for ASP.NET Core
Author: Mahmut Sarıkaya — sarikayadev.com