ASP.NET Core  

5 Hidden Gems in ASP.NET Core You Probably Aren’t Using

Unlock powerful built-in features to improve performance, reliability, and maintainability in your ASP.NET Core applications.

ASP.NET Core is full of amazing features, but many developers only use the basics: controllers, middleware, dependency injection, EF Core, and authentication. Hidden inside the framework are powerful tools that can dramatically improve your applications without third-party libraries or complex configurations.

This article explores five underrated features in ASP.NET Core that most developers overlook but should absolutely start using in modern applications. These features include:

  1. Background task processing with IHostedService

  2. Built-in Health Checks

  3. Endpoint Filters in ASP.NET Core 8

  4. HTTP/3 support

  5. Rate Limiting Middleware

Each of these features can help you build:

  • Faster apps

  • More stable APIs

  • Cleaner architecture

  • Better user experiences

Let’s dive into each gem in detail.

1. IHostedService for Background Tasks

The first hidden gem is using IHostedService to run recurring background tasks without external libraries like Hangfire or Quartz.

What is IHostedService?

IHostedService allows you to run background processes inside your ASP.NET Core application, such as:

  • Sending emails

  • Cleaning up expired records

  • Processing queues

  • Generating reports

  • Sending periodic notifications

And the best part?

  • No external scheduler required

  • Runs inside your application lifecycle

How It Works?

The Implementation using a timer to run recurring jobs:

public class BackgroundTask : IHostedService, IDisposable
{
    private Timer? _timer;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
        return Task.CompletedTask;
    }

    private void DoWork(object? state)
    {
        Console.WriteLine("Running background task...");
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }

    public void Dispose() => _timer?.Dispose();
}

Register it:

builder.Services.AddHostedService<BackgroundTask>();

When to Use It

Use IHostedService when you need:

  • Recurring jobs

  • Background operations

  • Timed processing

  • Queue workers

2. Built-in Health Checks

The Health Checks as a hidden but powerful feature for monitoring application health.

What Are Health Checks?

Health Checks allow your application to report the status of:

  • Database connections

  • Disk storage

  • External services

  • APIs

  • Custom dependencies

This is extremely valuable for production environments.

Why It Matters

This feature ensures your critical dependencies remain in good shape.

Systems like:

  • Kubernetes

  • Load balancers

  • Monitoring dashboards

Can automatically detect if your service is unhealthy and restart or reroute traffic.

3. Endpoint Filters in ASP.NET Core 8

Introduced in ASP.NET Core 8 and works like middleware but with more granular control.

What Are Endpoint Filters?

They allow you to apply logic only to specific endpoints, such as:

  • Validation

  • Logging

  • Response formatting

Unlike traditional middleware, endpoint filters target individual routes.

Why It’s Useful

The endpoint filters help avoid repetitive code and create cleaner APIs with centralised logic.

4. HTTP/3 Support

ASP.NET Core now includes HTTP/3 support out of the box, providing major performance improvements for modern applications.

Benefits of HTTP/3

HTTP/3 offers:

  • Reduced latency

  • Faster data transfer

  • Better performance for unreliable networks

Performance gains apply especially to:

  • Streaming video

  • Gaming

  • Real-time applications

How to Enable HTTP/3

The enabling HTTP/3 via appsettings configuration:

"Kestrel": {
  "Endpoints": {
    "HttpsDefault": {
      "Url": "https://localhost:5001",
      "Protocols": "Http1AndHttp2AndHttp3"
    }
  }
}

5. Rate Limiting Middleware

The final feature is the new Rate Limiting Middleware in ASP.NET Core.

Why Rate Limiting Matters

If you’re building public APIs, you must protect them from:

  • Abuse

  • Flooding

  • DDoS-style traffic

  • Overuse

This middleware helps maintain stable performance under heavy load.

Example

builder.Services.AddRateLimiter(options =>
{
    options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(
        context => RateLimitPartition.GetFixedWindowLimiter(
            "default",
            _ => new FixedWindowRateLimiterOptions
            {
                PermitLimit = 5,
                Window = TimeSpan.FromSeconds(10)
            }));
});

app.UseRateLimiter();

This limits clients to 5 requests per 10 seconds.

Membership not found