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:

Background task processing with IHostedService
Built-in Health Checks
Endpoint Filters in ASP.NET Core 8
HTTP/3 support
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();
}

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.