Adrián Bailador

Posted on May 17

Optimising ASP.NET Core APIs for Speed and Efficiency. Practical techniques to reduce latency, CPU usage, and memory allocations

#api #webdev #dotnet #csharp

Building a working API is one thing — building a fast and efficient API is another. As your application scales or handles more users, performance becomes a critical concern.

In this article, we’ll walk through practical techniques to optimise ASP.NET Core APIs for speed and efficiency, covering compression, caching, efficient serialisation, memory pressure, streaming, and monitoring.

🚀 1. Enable Response Compression

ASP.NET Core does not enable compression by default. Enabling it can drastically reduce payload sizes — especially for JSON-heavy responses.

📉 Example: a 45KB JSON payload can be reduced to 8KB with Gzip compression.

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<GzipCompressionProvider>();
    options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
        new[] { "application/json" });
});

builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
    options.Level = CompressionLevel.Fastest;
});

📖 Response compression in ASP.NET Core

🧠 2. Use Caching Strategically

Caching reduces redundant work and improves throughput dramatically.

🔸 a) Response Caching

Response caching stores entire responses and serves them directly, saving CPU cycles and database hits.

`csharp
builder.Services.AddResponseCaching();
app.UseResponseCaching();

[HttpGet]
[ResponseCache(Duration = 60)]
public IActionResult GetCachedData()
{
return Ok(new { message = "Cached response", time = DateTime.UtcNow });
}
`

🔸 b) In-Memory or Distributed Caching

Use IMemoryCache or IDistributedCache to cache database or computation-heavy results.

`csharp
public class MyService
{
private readonly IMemoryCache _cache;

public MyService(IMemoryCache cache) => _cache = cache;

public async Task<string> GetDataAsync()
{
    return await _cache.GetOrCreateAsync("data-key", entry =>
    {
        entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10);
        return FetchFromDatabaseAsync();
    });
}

}
`

📖 Caching in ASP.NET Core

🧩 3. Use Efficient JSON Serialisation

ASP.NET Core uses System.Text.Json by default — it's fast, but you can still tweak it for better results.

✅ Recommended options:

csharp builder.Services.Configure<JsonOptions>(options => { options.SerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull; options.SerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase; });

⚡ Advanced: Source Generators

Improves serialisation speed and reduces allocations.

csharp [JsonSerializable(typeof(MyResponseModel))] internal partial class MyJsonContext : JsonSerializerContext { }

csharp var json = JsonSerializer.Serialize(myData, MyJsonContext.Default.MyResponseModel);

📖 System.Text.Json overview

♻️ 4. Reduce Allocations and GC Pressure

Excessive allocations → frequent garbage collections → latency spikes. Use low-allocation patterns whenever possible.

✅ Tips:

Reuse buffers with ArrayPool<T>:

csharp var buffer = ArrayPool<byte>.Shared.Rent(1024); // use buffer... ArrayPool<byte>.Shared.Return(buffer);

Prefer readonly struct when the object is immutable and passed by reference.
Avoid unnecessary .ToList(), .Select() and LINQ operations in hot paths.
Don’t return IEnumerable<T> if the data is already materialised.

📖 Performance best practices for .NET

🌊 5. Stream Data When Possible

When returning large datasets, avoid loading the full result into memory.

✅ Use `IAsyncEnumerable<T>`:

csharp [HttpGet] public async IAsyncEnumerable<MyItem> StreamItems() { await foreach (var item in _repository.GetItemsAsync()) { yield return item; } }

This supports efficient streaming over HTTP/2, reducing memory pressure and improving time-to-first-byte.

⚙️ 6. Use Dependency Injection Efficiently

Registering your services properly avoids unnecessary instantiations and memory waste.

✅ Guidelines:

Singleton: for stateless and thread-safe services.
Scoped: for per-request lifetime.
Avoid injecting large services if only used conditionally.
Consider lazy loading via Lazy<T> or factory methods.

csharp services.AddSingleton<HttpClient>(); services.AddScoped<IMyService, MyService>();

📖 Dependency injection in ASP.NET Core

📈 7. Measure and Monitor

Don't optimise blindly. Always profile first.

✅ Tools:

BenchmarkDotNet — for isolated performance testing.
Visual Studio Profiler or JetBrains dotTrace
Runtime metrics with OpenTelemetry, Application Insights, or Prometheus.

✅ Performance Checklist

[ ] Is response compression enabled?
[ ] Are you using System.Text.Json with proper settings?
[ ] Are you caching expensive operations or results?
[ ] Have you measured and reduced memory allocations?
[ ] Are you streaming large data instead of loading all at once?
[ ] Is your dependency injection properly scoped?
[ ] Are you monitoring real performance metrics in production?

🔚 Conclusion

Efficient APIs aren’t just about fast code — they’re about thoughtful design, strategic trade-offs, and the right tools. These techniques help reduce latency, CPU load, and memory usage, making your APIs ready for real-world scale.

Optimise smartly. Profile often. And ship fast.