How to Use Distributed Caching in ASP.NET Core with Redis

Redis Object Cache – WordPress plugin | WordPress.org

Introduction

When you build an ASP.NET Core application, one of the biggest challenges is performance. As your application grows and more users start using it, your database gets hit again and again for the same data. This slows down your application and increases server load.

This is where distributed caching with Redis helps.

Instead of calling the database every time, you store frequently used data in a fast in-memory system like Redis. The next time someone requests the same data, it is returned instantly from the cache instead of the database.

In this guide, you will learn step-by-step how to use Redis distributed caching in ASP.NET Core in simple and practical terms.

What is Distributed Caching?

Distributed caching means storing your cached data outside your application, usually in a separate service like Redis.

In a normal (in-memory) cache, data is stored inside a single server. If your application runs on multiple servers, each server will have its own cache, which can cause inconsistency.

But in distributed caching:

All servers share the same cache
Data remains consistent across the application
It works well in scalable environments

In simple words, distributed cache is like a shared memory that all your application servers can use.

What is Redis?

Redis is a very fast, in-memory data store that is widely used for caching.

Think of Redis as a super-fast dictionary where:

You store data using a key
You retrieve data using the same key

Why developers prefer Redis:

It is extremely fast because it stores data in memory
It supports simple key-value storage
It is easy to integrate with ASP.NET Core
It works great for scalable and cloud-based applications

Prerequisites

Before starting, make sure you have the following ready:

.NET SDK installed on your system
A working ASP.NET Core project
Redis installed locally or access to a cloud Redis service
Basic understanding of controllers and services in ASP.NET Core

If Redis is not installed locally, you can use Docker or any cloud provider.

Step 1: Install Required NuGet Package

First, you need to install the Redis caching package.

Run the following command:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

This package connects your ASP.NET Core application with Redis and enables distributed caching support.

Step 2: Configure Redis in ASP.NET Core

Next, you need to tell your application how to connect to Redis.

Open your Program.cs file and add the following configuration:

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

Explanation in simple terms:

localhost:6379 → This is the address where Redis is running
InstanceName → A prefix added to all cache keys (helps in organizing data)

If you are using cloud Redis, replace the localhost value with your connection string.

Step 3: Inject IDistributedCache Service

ASP.NET Core provides a built-in interface called IDistributedCache to work with Redis.

You need to inject it into your service or controller.

public class ProductService
{
    private readonly IDistributedCache _cache;

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

In simple words, this allows your class to talk to Redis.

Step 4: Store Data in Redis Cache

To store data in Redis, you use the SetStringAsync method.

public async Task SetCacheDataAsync(string key, string value)
{
    var options = new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
    };

    await _cache.SetStringAsync(key, value, options);
}

What is happening here:

You are saving data using a unique key
You are setting an expiration time (10 minutes)

Why expiration is important:

Prevents outdated data
Keeps cache clean
Saves memory

Step 5: Retrieve Data from Cache

To get data from Redis, you use:

public async Task<string> GetCacheDataAsync(string key)
{
    return await _cache.GetStringAsync(key);
}

If the data exists, it returns instantly.
If not, it returns null.

This is much faster than calling the database.

Step 6: Implement Cache-Aside Pattern

The most common way to use caching is the Cache-Aside pattern.

This means:

First check cache
If data exists → return it
If not → fetch from database and store in cache

Example:

public async Task<string> GetProductAsync(string productId)
{
    string cacheKey = $"product_{productId}";

    var cachedData = await _cache.GetStringAsync(cacheKey);

    if (!string.IsNullOrEmpty(cachedData))
    {
        return cachedData;
    }

    var productData = "Product from Database";

    await _cache.SetStringAsync(cacheKey, productData, new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
    });

    return productData;
}

This approach:

Reduces database calls
Improves response time
Automatically fills cache when needed

Step 7: Working with Complex Objects

Redis stores data as strings, so for objects, you need to convert them into JSON.

public async Task SetObjectAsync<T>(string key, T data)
{
    var jsonData = JsonSerializer.Serialize(data);

    await _cache.SetStringAsync(key, jsonData);
}

public async Task<T> GetObjectAsync<T>(string key)
{
    var jsonData = await _cache.GetStringAsync(key);

    return jsonData == null ? default : JsonSerializer.Deserialize<T>(jsonData);
}

In simple words:

Convert object → JSON → store in Redis
Retrieve JSON → convert back to object

Step 8: Remove Data from Cache

Sometimes you need to delete outdated or incorrect cache data.

await _cache.RemoveAsync("product_1");

This is useful when:

Data is updated in database
Cache becomes invalid

Step 9: Best Practices for Redis Caching

To use Redis effectively, follow these simple practices:

Use clear and unique cache keys
Always set expiration time
Do not cache sensitive data
Avoid storing very large objects
Monitor cache usage and performance

These practices help maintain performance and avoid issues later.

Step 10: Common Use Cases

Redis caching is commonly used for:

API response caching
Product listings
User sessions
Frequently accessed data
Dashboard data

If data is read frequently but changes less often, it is a good candidate for caching.

Advantages of Using Redis in ASP.NET Core

Using Redis gives several benefits:

Faster application performance
Reduced database load
Better scalability
Improved user experience

It is especially useful in high-traffic applications.

Summary

Distributed caching with Redis in ASP.NET Core is a simple yet powerful way to improve application performance. Instead of repeatedly calling the database, you store frequently used data in Redis and retrieve it quickly when needed. By following the step-by-step approach, using patterns like Cache-Aside, and applying best practices, you can build fast, scalable, and efficient applications. Start small, implement caching where it matters most, and gradually optimize your system for better performance.