Optimizing Performance with Caching in .NET Core APIs

In-memory caching, Distributed Caching (e.g., Redis), Response Caching, Cache-Aside Pattern

When building modern APIs, performance is king. With users expecting lightning-fast responses, one of the easiest and most efficient ways to boost performance is through caching. But caching can often feel like a mystery, especially when you want to ensure it's done the right way in .NET Core.

In this blog, we’ll explore what caching is, why it’s so important for API performance, and walk you through some powerful caching strategies using .NET Core.

So, whether you’re new to caching or looking to refine your API performance, buckle up! Let's optimize those responses!

What is Caching and Why Does It Matter?

Think of caching as a shortcut. Rather than making your application do the same work over and over (like hitting the database or calling an external API), caching stores precomputed results or frequently requested data in memory. So, when the same request comes in, you can serve the cached response in a fraction of the time.

Here’s a real-world analogy:

• Imagine you run a coffee shop, and every morning, dozens of customers order the same cappuccino. Instead of grinding beans, steaming milk, and brewing each cappuccino individually, you prepare a big batch ahead of time. When customers order, you can serve them instantly from your prepared batch—much faster, right?

Similarly, caching allows your API to serve data faster, reducing load on your server and providing an instant response to users.

Caching Strategies in .NET Core

There are several ways to implement caching in .NET Core. Let’s focus on the most popular ones and how they can significantly boost your API’s performance.

1. In-Memory Caching

2. Distributed Caching (e.g., Redis)

3. Response Caching

4. Cache-Aside Pattern

1. In-Memory Caching: The Quick and Easy Way

In-memory caching stores data in the memory of the web server. It’s fast because it’s stored in RAM but is also limited since data is lost when the server restarts, and it doesn't scale well across multiple servers.

How to Implement In-Memory Caching

Let’s walk through an example of how to implement in-memory caching in a .NET Core API.

First, make sure to add Microsoft.Extensions.Caching.Memory if it’s not already in your project.

1. Enable In-Memory Caching in Startup

In your Startup.cs file, add the caching service in the ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMemoryCache();
    services.AddControllers();
}

2. Use Caching in Your API Controller

Now, let’s say you have a controller that gets a list of products. We can cache the result for faster subsequent responses.

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

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

    [HttpGet]
    public IActionResult GetProducts()
    {
        var cacheKey = "productList";
        if (!_cache.TryGetValue(cacheKey, out List<Product> products))
        {
            // Simulate fetching data from a database or external service
            products = FetchProductsFromDatabase();

            // Set cache options (optional: expiration time, etc.)
            var cacheEntryOptions = new MemoryCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
            };

            // Cache the data
            _cache.Set(cacheKey, products, cacheEntryOptions);
        }

        return Ok(products);
    }

    private List<Product> FetchProductsFromDatabase()
    {
        // Imagine this is a database call
        return new List<Product>
        {
            new Product { Id = 1, Name = "Laptop", Price = 999 },
            new Product { Id = 2, Name = "Smartphone", Price = 799 }
        };
    }
}

How This Works:

• We check if the product list is already cached (TryGetValue).

• If it's not cached, we fetch the data from the database and then cache it.

• The next time someone requests the product list, the cached data is returned, skipping the database query.

You can also configure cache expiration by setting cache options, such as absolute expiration or sliding expiration.

2. Distributed Caching: Scaling Your Cache (Using Redis)

While in-memory caching is great for a single server, distributed caching comes to the rescue when you have multiple servers or need persistent caching. Redis is a popular distributed cache that stores data in memory across a cluster, providing fast access and high availability.

Implementing Redis Caching in .NET Core

1. Install the Redis Package

First, install the Redis NuGet package:

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

2. Configure Redis in Startup

In your Startup.cs, configure the Redis cache:

public void ConfigureServices(IServiceCollection services)
{
    services.AddStackExchangeRedisCache(options =>
    {
        options.Configuration = "localhost:6379"; // Replace with your Redis connection string
        options.InstanceName = "MyRedisInstance";
    });

    services.AddControllers();
}

3. Use Redis in Your API Controller

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

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

    [HttpGet]
    public async Task<IActionResult> GetProductsAsync()
    {
        var cacheKey = "productList";
        string cachedProducts = await _cache.GetStringAsync(cacheKey);
        List<Product> products;

        if (string.IsNullOrEmpty(cachedProducts))
        {
            // Fetch data from the database (simulated)
            products = FetchProductsFromDatabase();

            // Serialize and store data in Redis
            cachedProducts = JsonConvert.SerializeObject(products);
            await _cache.SetStringAsync(cacheKey, cachedProducts, new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
            });
        }
        else
        {
            // Deserialize cached data
            products = JsonConvert.DeserializeObject<List<Product>>(cachedProducts);
        }

        return Ok(products);
    }

    private List<Product> FetchProductsFromDatabase()
    {
        // Simulate a database call
        return new List<Product>
        {
            new Product { Id = 1, Name = "Laptop", Price = 999 },
            new Product { Id = 2, Name = "Smartphone", Price = 799 }
        };
    }
}

How This Works:

• The controller checks the Redis cache for the product list.

• If the data is not cached, it fetches the data, serializes it, and stores it in Redis.

• On subsequent requests, the cached data is retrieved from Redis, reducing the need to hit the database.

3. Response Caching: Quick Wins with API Responses

If you’re looking for an easy way to cache entire responses (like HTML pages or API responses), you can use Response Caching. This works great when the same request is frequently made by users.

1. Enable Response Caching in Startup

public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCaching();
    services.AddControllers();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseResponseCaching();
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}

2. Use Response Caching in Controller

[HttpGet]
[ResponseCache(Duration = 60)]
public IActionResult Get()
{
    return Ok(new { Message = "This response is cached for 60 seconds." });
}

How This Works:

• The response is cached for the specified duration (in seconds).

• Subsequent requests within the cache duration will return the cached response.

4. Cache-Aside Pattern: Let Your Cache Work Smarter

The Cache-Aside Pattern is a popular strategy where your application checks the cache first, and if the data isn’t available, it fetches the data from the source (database), caches it, and returns it.

Here’s a simplified process:

1. Look for data in the cache.

2. If found, return the cached data.

3. If not found, fetch the data from the database, cache it, and return it.

This pattern works well in distributed caching systems and is often combined with Redis or in-memory caching.

Bonus: Eviction Policies and Cache Best Practices

When working with caching, keep these best practices in mind:

1. Set expiration times: Don’t cache data forever! Use appropriate expiration times based on the data type.

2. Evict stale data: Ensure stale or outdated data is removed from the cache when it’s no longer relevant.

3. Monitor cache usage: Keep an eye on memory usage and cache hits/misses to optimize performance.

4. Cache only frequently requested data: Cache data that’s frequently accessed and relatively static.

Conclusion: Boost Your API’s Speed

Caching is an incredibly powerful tool for optimizing performance in .NET Core APIs. By leveraging in-memory caching, distributed caching (Redis), and response caching, you can significantly reduce database calls, improve response times, and scale your application more efficiently.

So, next time your API feels a little sluggish, think caching! It might just be the solution to supercharge your performance.

What caching strategies have you used in your .NET Core APIs? Let’s start a conversation in the comments!