How to Implement Redis Caching in ASP.NET Core?

Caching is one of the most effective strategies to improve performance, scalability, and response time in modern web applications. In ASP.NET Core applications, Redis caching is widely used to reduce database load, minimize latency, and handle high-traffic scenarios efficiently. This guide explains Redis caching in ASP.NET Core in a production-grade manner, covering definitions, internal architecture, real-world scenarios, implementation steps, best practices, and common mistakes.

What is Redis Caching?

Redis (Remote Dictionary Server) is an in-memory distributed data store used as a cache, database, and message broker. Unlike in-memory caching that stores data inside a single application instance, Redis runs as a separate service and can be shared across multiple servers.

In simple terms, Redis acts like a super-fast temporary storage layer between your ASP.NET Core application and your database.

Real-world analogy:
Think of Redis as a frequently used notes board in an office. Instead of asking the manager (database) the same question repeatedly, employees check the notes board first. If the information is available there, they save time and reduce workload on the manager.

Why Do We Need Redis Caching in ASP.NET Core?

Without caching:

Every request hits the database
Database CPU usage increases
Application response time slows down
Scaling becomes expensive

With Redis caching:

Frequently requested data is served from memory
Database load decreases significantly
Response time improves dramatically
Application handles higher traffic

Real-world production scenario:
Imagine an e-commerce ASP.NET Core API where thousands of users are requesting product details every second. Without caching, every request queries SQL Server. With Redis caching, product data is cached for a short duration, and repeated requests are served instantly from memory.

Internal Architecture Flow of Redis Caching

Client Request
↓
ASP.NET Core Controller
↓
Check Redis Cache
↓
If Data Exists → Return Cached Data
↓
If Data Missing → Query Database
↓
Store Result in Redis
↓
Return Response

Redis runs as a separate distributed service, allowing multiple ASP.NET Core instances to share the same cache.

Types of Caching in ASP.NET Core

In-Memory Cache (IMemoryCache)
Distributed Cache (IDistributedCache)
Redis Distributed Cache

When building scalable or cloud-based applications, Redis Distributed Cache is recommended.

Difference Between In-Memory Cache and Redis Cache

Feature	In-Memory Cache	Redis Cache
Storage Location	Inside application process	External distributed server
Scalability	Limited to single instance	Supports multiple instances
Persistence	Lost on app restart	Can be persisted
Suitable for Microservices	No	Yes
Performance	Very fast	Very fast (network latency included)
Cloud Friendly	Limited	Highly suitable

Prerequisites

ASP.NET Core Web API project
Redis installed locally or Azure Cache for Redis
.NET CLI or Visual Studio

Step 1: Install Redis Package

Install the required NuGet package:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

Step 2: Configure Redis in Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost:6379";
    options.InstanceName = "SampleInstance";
});

builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();

app.Run();

Explanation:

AddStackExchangeRedisCache registers Redis as a distributed cache provider.
Configuration defines Redis server location.
InstanceName acts as a prefix for cache keys.

For Azure Cache for Redis, replace the configuration string with the Azure connection string.

Step 3: Implement Caching in Controller

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;

[ApiController]
[Route("api/products")]
public class ProductsController : ControllerBase
{
    private readonly IDistributedCache _cache;

    public ProductsController(IDistributedCache cache)
    {
        _cache = cache;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        string cacheKey = $"product_{id}";

        var cachedData = await _cache.GetStringAsync(cacheKey);

        if (!string.IsNullOrEmpty(cachedData))
        {
            return Ok(JsonSerializer.Deserialize<object>(cachedData));
        }

        var product = new
        {
            Id = id,
            Name = "Laptop",
            Price = 50000
        };

        var options = new DistributedCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));

        await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(product), options);

        return Ok(product);
    }
}

Explanation:

First, we check if data exists in Redis.
If found, return cached result.
If not found, fetch from database (simulated here).
Store result in Redis with expiration.
Return response.

Absolute vs Sliding Expiration

Absolute Expiration: Cache expires after fixed time.
Sliding Expiration: Cache expires if not accessed within specific duration.

Use absolute expiration for stable data (product catalog).
Use sliding expiration for session-like data.

Real-World Use Cases of Redis in ASP.NET Core

Caching product catalog in e-commerce
Storing authentication tokens
Session storage for distributed systems
Rate limiting counters
Frequently accessed configuration data
Leaderboards in gaming applications

Advantages of Redis Caching

Extremely fast data access
Reduces database load
Supports distributed systems
High scalability
Supports advanced data structures
Cloud-friendly

Disadvantages of Redis Caching

Additional infrastructure cost
Network dependency
Requires proper cache invalidation strategy
Possible stale data if expiration not managed correctly

Common Mistakes Developers Make

Caching everything unnecessarily
Not setting expiration time
Ignoring cache invalidation logic
Storing large objects inefficiently
Keeping connection string in source code

When NOT to Use Redis Caching

When application is very small and single-instance
When data changes constantly and cannot tolerate staleness
When infrastructure cost must be minimal

Best Practices for Production

Use cache-aside pattern
Use consistent cache key naming convention
Monitor cache hit ratio
Secure Redis with authentication
Use Azure Cache for Redis for enterprise workloads
Avoid caching sensitive data without encryption

Summary

Implementing Redis caching in ASP.NET Core significantly improves application performance by reducing database load and serving frequently requested data directly from memory. By integrating StackExchangeRedis, configuring distributed caching, implementing cache-aside patterns, and managing expiration strategies properly, developers can build scalable and high-performance web APIs suitable for enterprise and cloud-native architectures. When used correctly with proper invalidation strategies and monitoring, Redis becomes a powerful performance optimization layer for modern ASP.NET Core applications.