Asp.Net Web Api Output Caching And In Memory Caching Complete Guide

ASP.NET Web API Output Caching

Output Caching in ASP.NET Web API allows you to cache the HTTP response output. This way, if a client makes the same request again, the server returns the cached response instead of processing the request again.

However, it's important to note that ASP.NET Core Web API does not support output caching directly like ASP.NET MVC. Instead, we use Response Caching Middleware which provides similar functionality.

Step 1: Set up a basic ASP.NET Core Web API project

• First, ensure you have .NET SDK installed.
• Create a new ASP.NET Core Web API project using Visual Studio or command line:

dotnet new webapi -n WebApiCachingExample
cd WebApiCachingExample

Step 2: Configure Response Caching Middleware

• Open Startup.cs or Program.cs depending on your project setup.
• Add Response Caching Middleware to the services and configure it:

In Program.cs for .NET 6 and above:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

// Register Response Caching Service
builder.Services.AddResponseCaching();

var app = builder.Build();

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

app.UseHttpsRedirection();

app.UseAuthorization();

// Use Response Caching Middleware
app.UseResponseCaching();

app.MapControllers();

app.Run();

Step 3: Implement Output Caching in a Controller

Here’s how you can add caching to an action method in a controller.

Create a new controller WeatherForecastController:

using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;

[ApiController]
[Route("api/[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    [HttpGet(Name = "GetWeatherForecast")]
    [ResponseCache(Duration = 120)]
    public IEnumerable<WeatherForecast> Get()
    {
        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

    public string? Summary { get; set; }
}

Explanation:

• The [ResponseCache(Duration = 120)] attribute tells the middleware to cache the response for 120 seconds.
• You must also send the Cache-Control header in each request for ASP.NET Core Response Caching to work effectively.

Step 4: Send Cache-Control Headers from Client

You can send the Cache-Control headers from your client to specify caching behavior.

Using Postman:

1. Go to your POSTMAN application.
2. Select a GET request to the endpoint /api/WeatherForecast.
3. Add a header Cache-Control with the value max-age=120.
4. Send the request several times.

The server should return the same result after the first request within 120 seconds, showing that the response is being cached.

ASP.NET Web API In-Memory Caching

In-Memory Caching is a powerful feature provided by ASP.NET Core which allows you to store data into memory. This example will show you how to manually implement caching in your API using MemoryCache.

Step 1: Configure MemoryCache

• In Program.cs, register the IMemoryCache service:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

// Register IMemoryCache Service
builder.Services.AddMemoryCache();

var app = builder.Build();

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

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 2: Create a Service for Caching

• For demonstration purposes, let's create a simple service that caches some data.

Create MemoryCacheService.cs:

using Microsoft.Extensions.Caching.Memory;
using System;

public class MemoryCacheService
{
    private readonly IMemoryCache _memoryCache;

    public MemoryCacheService(IMemoryCache memoryCache)
    {
        _memoryCache = memoryCache;
    }

    public bool TryGetValue(string cacheKey, out object cacheEntry)
    {
        return _memoryCache.TryGetValue(cacheKey, out cacheEntry);
    }

    public void Set(string cacheKey, object cacheEntry, TimeSpan slidingExpirationTimeSpan)
    {
        _memoryCache.Set(cacheKey, cacheEntry, new MemoryCacheEntryOptions()
        {
            SlidingExpiration = slidingExpirationTimeSpan
        });
    }
}

Explanation:

• TryGetValue method tries to retrieve the cache entry based on the provided key.
• Set method sets the cache entry and specifies a sliding expiration time.

Step 3: Use MemoryCacheService in a Controller

• Inject and use MemoryCacheService in your controller to manage caching.

Modify WeatherForecastController:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System;
using System.Collections.Generic;

[ApiController]
[Route("api/[controller]")]
public class WeatherForecastController : ControllerBase
{
    private readonly string _cacheKey = "WeatherForecasts";
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };
    private readonly MemoryCacheService _memoryCacheService;

    public WeatherForecastController(MemoryCacheService memoryCacheService)
    {
        _memoryCacheService = memoryCacheService;
    }

    [HttpGet(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        // Try to get data from cache
        if (_memoryCacheService.TryGetValue(_cacheKey, out object cachedData))
        {
            return (IEnumerable<WeatherForecast>)cachedData;
        }

        // If no cache entry found, generate data
        var rng = new Random();
        var weatherForecasts = Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();

        // Store in cache with sliding expiration
        _memoryCacheService.Set(_cacheKey, weatherForecasts, TimeSpan.FromMinutes(2));

        return weatherForecasts;
    }
}

public class WeatherForecast
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

    public string? Summary { get; set; }
}

Explanation:

• The controller now checks whether its data is already in the cache using _memoryCacheService.TryGetValue.
• If the data is not found in the cache, it generates the data, stores it into the cache using _memoryCacheService.Set, and then returns it.
• The TimeSpan.FromMinutes(2) parameter sets sliding expiration for the cache entry. This means that if the data is accessed within 2 minutes, it won't expire. If it is not accessed within this period, it will be removed.

Step 4: Test Your Application

Run the application and make requests to the /api/WeatherForecast endpoint. You can see that the data returned is the same if you query again within the sliding expiration time period. This confirms that the data is being stored and retrieved from the in-memory cache.