Caching In Asp.Net Core Complete Guide

Prerequisites

1. Install .NET SDK: Ensure you have the .NET SDK installed, preferably the latest LTS version.

2. Create a New Project: Open your terminal or command prompt, navigate to a directory where you want to create the project, and run:

   dotnet new webapi -n CachingExample
   

3. Install Required Packages: Navigate into the newly created project directory and install the required NuGet packages.

   cd CachingExample
   dotnet add package Microsoft.Extensions.Caching.Memory
   dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis
   dotnet add package StackExchange.Redis  # Ensure you have the latest version
   

4. Configure Redis: For the distributed cache example, you need to have a running instance of Redis. You can use the following Docker command to start a Redis container locally:

   docker run -d --name my-redis -p 6379:6379 redis
   

Memory Cache Example

This example demonstrates how to use the built-in memory cache in ASP.NET Core.

1. Configure Services

First, modify the Program.cs file to configure memory caching.

using Microsoft.Extensions.Caching.Memory;
using CachingExample.Controllers;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddMemoryCache(); // Register the memory cache service

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();

app.MapControllers();

app.Run();

2. Create a Controller Using Memory Cache

Let's create a simple controller that retrieves data from the cache or generates it if it doesn't exist.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace CachingExample.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class MemoryCacheController : ControllerBase
    {
        private readonly IMemoryCache _memoryCache;
        private readonly ILogger<MemoryCacheController> _logger;

        public MemoryCacheController(IMemoryCache memoryCache, ILogger<MemoryCacheController> logger)
        {
            _memoryCache = memoryCache;
            _logger = logger;
        }

        [HttpGet("data")]
        public async Task<IActionResult> GetDataAsync()
        {
            const string cacheKey = "DataKey";
            var data = await _memoryCache.GetOrCreateAsync(cacheKey, async entry =>
            {
                entry.SlidingExpiration = TimeSpan.FromSeconds(30); // Cache expires after 30 seconds if not accessed
                _logger.LogInformation("Data generated for first time or cache expired.");
                return await GenerateDataAsync();
            });

            _logger.LogInformation("Returning cached data.");
            return Ok(new { Data = data });
        }

        private async Task<string> GenerateDataAsync()
        {
            // Simulate a long-running operation or data retrieval process
            await Task.Delay(500); 
            return $"Generated at {DateTime.Now}";
        }
    }
}

3. Test the Endpoint

Run the application:

dotnet run

Now, make requests to the endpoint to see the caching in action:

• GET http://localhost:5000/api/memorycache/data

The first request will generate new data and log it. Subsequent requests within 30 seconds will return the cached data and log accordingly.

Distributed Cache Example with Redis

This example demonstrates setting up a distributed cache using Redis in ASP.NET Core.

1. Configure Services

Modify the Program.cs file to configure distributed caching with Redis.

using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.StackExchangeRedis;
using Microsoft.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddDistributedRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "SampleInstance";
});
builder.Services.AddLogging();

var app = builder.Build();

// Configure the connection string for Redis in appsettings.json
builder.Configuration.AddJsonFile("appsettings.json");

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();

app.MapControllers();

app.Run();

Add your Redis connection string in appsettings.json:

{
  "ConnectionStrings": {
    "Redis": "localhost:6379,password=yourpassword,abortConnect=false,syncTimeout=30000"
  }
}

If you are running Redis without a password, just set it to an empty string:

"Redis": "localhost:6379,abortConnect=false,syncTimeout=30000"

2. Create a Controller Using Distributed Cache

Let's create a similar controller that uses the distributed cache provided by Redis.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Logging;
using System.Text;
using System.Threading.Tasks;

namespace CachingExample.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class RedisCacheController : ControllerBase
    {
        private readonly IDistributedCache _distributedCache;
        private readonly ILogger<RedisCacheController> _logger;

        public RedisCacheController(IDistributedCache distributedCache, ILogger<RedisCacheController> logger)
        {
            _distributedCache = distributedCache;
            _logger = logger;
        }

        [HttpGet("data")]
        public async Task<IActionResult> GetDataAsync()
        {
            const string cacheKey = "DataKey";
            var data = await _distributedCache.GetStringAsync(cacheKey);
            
            if (data == null)
            {
                data = await GenerateDataAsync();
                _logger.LogInformation("Data generated for first time or cache expired.");

                var options = new DistributedCacheEntryOptions()
                    .SetAbsoluteExpiration(TimeSpan.FromSeconds(60)); // Cache expires after 60 seconds

                await _distributedCache.SetStringAsync(cacheKey, data, options);
            }
            else
            {
                _logger.LogInformation("Returning cached data.");
            }

            return Ok(new { Data = data });
        }

        private async Task<string> GenerateDataAsync()
        {
            // Simulate a long-running operation or data retrieval process
            await Task.Delay(500);
            return $"Generated at {DateTime.Now}";
        }
    }
}

3. Test the Endpoint

Run the application:

dotnet run

Make requests to the new endpoint to observe the distributed caching:

• GET http://localhost:5000/api/rediscache/data

The first request will generate new data, store it in Redis, and log it. Subsequent requests within 60 seconds will return the cached data from Redis and log accordingly.

Additional Notes

Clearing Cache

Sometimes, you might need to clear the cache manually. Here’s how you can do it in both memory and distributed cache scenarios:

Memory Cache

_memoryCache.Remove(cacheKey);

Distributed Cache

await _distributedCache.RemoveAsync(cacheKey);

Refreshing or Updating Cache

To update or refresh the cache, simply add or set the new value with the appropriate expiration settings.

Memory Cache

_memoryCache.Set(cacheKey, newData, new MemoryCacheEntryOptions
{
    SlidingExpiration = TimeSpan.FromSeconds(30),
});

Distributed Cache

await _distributedCache.SetStringAsync(cacheKey, newData, new DistributedCacheEntryOptions
{
    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(60),
});

Distributed Cache Serialization

When dealing with complex objects in IDistributedCache, ensure they are serialized properly. JSON is a common choice for serialization.

Example: Serialize and Deserialize Complex Object

using Newtonsoft.Json;

public async Task<MyDataObject> GetMyDataObjectAsync()
{
    const string cacheKey = "MyDataKey";
    string serializedData = await _distributedCache.GetStringAsync(cacheKey);
    
    MyDataObject dataObject = null;

    if (serializedData != null)
    {
        dataObject = JsonConvert.DeserializeObject<MyDataObject>(serializedData);
        _logger.LogInformation("Returning cached object.");
        return dataObject;
    }
    else
    {
        dataObject = await GenerateMyDataObjectAsync();
        _logger.LogInformation("Data object generated for first time or cache expired.");

        var options = new DistributedCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromHours(1));

        string newData = JsonConvert.SerializeObject(dataObject);
        await _distributedCache.SetStringAsync(cacheKey, newData, options);
    }

    return dataObject;
}

private async Task<MyDataObject> GenerateMyDataObjectAsync()
{
    // Simulate generating a complex data object
    await Task.Delay(500);
    return new MyDataObject
    {
        Id = Guid.NewGuid(),
        Name = "Example",
        CreatedAt = DateTime.Now
    };
}

Where MyDataObject is defined as:

public class MyDataObject
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public DateTime CreatedAt { get; set; }
}

Conclusion

Implementing caching in ASP.NET Core can significantly improve the performance of your web applications by reducing the load on your data sources and decreasing response times. In this example, we explored using both memory and distributed caching mechanisms with Redis, covering basic operations like setting, retrieving, clearing, refreshing, and serializing data.