Scale ASP.NET Core Web APIs with Distributed Caching

As user numbers and traffic increase, the capacity to scale effectively guarantees that your application can meet such rising demands without sacrificing performance. Especially when using ASP.NET Core Web APIs to develop modern web applications, scalability is a primary concern. A great way to accomplish this is by using a distributed cache. This approach reduces the load on your database and improves response times.

This blog discusses how NCache, a high-performance distributed cache, can be used to improve the scalability of ASP.NET Core Web APIs. It covers several caching techniques, implementation steps, and essential features that make distributed caching a crucial component of a scalable architecture.

Why Use Distributed Caching for Web APIs?

A Web API typically gets data from some external service or database which introduces latency. Caching alleviates latency by storing the frequently retrieved data in memory for faster access. Distributed caching has additional advantages such as:

Enhanced Scalability: Allows API servers to scale horizontally without redundant database queries.
Improved Response Times: Cached data is served instantly from memory thereby improving response times.
Reduced Database Load: Minimizes direct database interactions by serving cached responses.
Consistent Performance Under Load: Helps maintain stable response times during peak usage.
Optimized Network Traffic: Reduces backend API calls by caching responses.
Support for Microservices: Enables shared caching across distributed services.

Figure: Distributed cache.

Implementing NCache in ASP.NET Core Web APIsStep 1: Install NCache NuGet Package

To get started, install the Alachisoft.NCache.SDK package in your ASP.NET Core Web API project (x.x.x is your chosen NCache version):

1	dotnet add package Alachisoft.NCache.SDK --version x.x.x

Step 2: Configure NCache in ASP.NET Core

Modify your Program.cs file to register NCache in the dependency injection (DI) container using the latest .NET dependency injection practices:

var builder = WebApplication.CreateBuilder(args);

// Add NCache Distributed Cache

builder.Services.AddNCacheDistributedCache(options =>

{

options.CacheName = "demoCache";

options.ServerList = "127.0.0.1";

options.EnableLogs = true;

});

var app = builder.Build();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 3: Using NCache with Entity Framework Core

To further optimize performance, you can cache database query results. Below is an example of integrating EF Core with NCache:

public class ProductService

{

private readonly ApplicationDbContext _context;

private readonly ICache _cache;

public ProductService(ApplicationDbContext context, ICache cache)

{

_context = context;

_cache = cache;

}

public async Task<Product> GetProductByIdAsync(int id)

{

string cacheKey = $"product-{id}";

var cachedProduct = await _cache.GetAsync<object>($1);

if (!string.IsNullOrEmpty(cachedProduct))

{

return JsonSerializer.Deserialize<Product>(cachedProduct);

}

var product = await _context.Products.FindAsync(id);

if (product != null)

{

await _cache.InsertAsync($1, $2, new DistributedCacheEntryOptions { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10) });

}

return product;

}

Deploying ASP.NET Core Web APIs with NCache

Step 1: Publish and Host on IIS

Publish your API:

1

dotnet publish -c Release -o ./publish
Copy the publish folder to the Windows Server.
Open IIS Manager, create a new application pool, and add a new site.
Set the physical path to the publish folder and configure the site to use the correct framework.

Step 2: Configure NCache on Windows Server

Install NCache on the Windows Server.
Open NCache Management Center and create a new cache cluster.
Add server nodes and configure cache settings.
Start the cache service and ensure it is running properly.

Step 3: Connect API to NCache Server

Update appsettings.json in your API to point to the NCache server:

{

"NCache": {

"CacheName": "demoCache",

"ServerList": "192.168.1.100"

}

Conclusion

Integrating NCache with ASP.NET Core Web APIs enhances scalability and performance. By reducing database load and improving response times, distributed caching ensures applications can handle increased traffic efficiently. Developers can leverage NCache to implement high-availability caching strategies, optimize API performance, and deliver seamless user experiences.

By adopting best practices, such as caching frequently accessed data and leveraging NCache with EF Core, you can build a robust and scalable Web API that meets the demands of modern applications.