How To Implement Caching In The .NET Core Web API Application

CacheKeys.cs

public static class CacheKeys
{
	public static string Employees => "_Employees";
}

In the above code, whenever the request is coming, first check whether the cache has value (employee details) or not. If not, then employees' details are retrieved from the database and stored in the cache. Since the cache has employee details, for the next request, the employee details are fetched from the cache instead of the database.

In-Memory Cache Parameters

• SizeThis allows you to: Set the size of this particular cache entry so that it doesn’t start consuming the server resources.
• SlidingExpiration: How long the Cache will be inactive? A cache entry will expire if it is not used by anyone for this particular time period. In our case, we have set SlidingExpiration is 2 minutes. If there are no requests for this cache entry for 2 minutes, then the cache will be deleted.
• AbsoluteExpiration: Actual expiration time for cached Value. Once the time is reached, then the cache entry will be removed. In our case, we have set AbsoluteExpiration is 5 minutes. The cache will expire once the time is reached 5 minutes. Absolute expiration should not be less than the Sliding Expiration.

Output

First-time Request

Second Request

Problems

If there are multiple requests at the same time for the same item, then the requests won't wait for the first one to be complete. Since there are no values in the cache, the database calls happen to all requests until the cache has been set.

For example.

1. User 'A' sends a request for the employee details. Here cache doesn't have any values. So, this request calls the database to retrieve the employee details. Let’s consider that getting employee details from the database takes 5 seconds.
2. Meanwhile (Before completing the User 'A' request), User 'B' sends a request for the same employee details. Here the cache doesn't have any value. So, this request also has a database call.

Cache Implementation using lock

We are going to use the lock to solve the above problem.

For example,

1. User 'A' sends the request for the employee details. Here cache doesn't have any values. So, it enters into the lock state and makes database calls for retrieving the employee details.
2. Meanwhile, User 'B' sends the request for the employee details. This request will wait until the lock is released. This will reduce the database call for the same data.
3. Once employee details are retrieved from the database, it's stored in the cache. Now, the lock is released and sends a response to User 'A'.
4. Now, the values are fetched from the cache and sent a response to User 'B'.

We are going to refactor the cache mechanism using locks. Let's consider the below code.

EmployeeController.cs

[Route("api/[controller]")]
public class EmployeeController: ControllerBase {
    private ICacheProvider _cacheProvider;
    public EmployeeController(ICacheProvider cacheProvider) {
            _cacheProvider = cacheProvider;
        }
        [Route("getAllEmployee")]
    public IActionResult GetAllEmployee() {
        try {
            var employees = _cacheProvider.GetCachedResponse().Result;
            return Ok(employees);
        } catch (Exception ex) {
            return new ContentResult() {
                StatusCode = 500,
                    Content = "{ \n error : " + ex.Message + "}",
                    ContentType = "application/json"
            };
        }
    }
}

CacheProvider.cs

public class CacheProvider: ICacheProvider {
    private static readonly SemaphoreSlim GetUsersSemaphore = new SemaphoreSlim(1, 1);
    private readonly IMemoryCache _cache;
    public CacheProvider(IMemoryCache memoryCache) {
        _cache = memoryCache;
    }
    public async Task < IEnumerable < Employee >> GetCachedResponse() {
        try {
            return await GetCachedResponse(CacheKeys.Employees, GetUsersSemaphore);
        } catch {
            throw;
        }
    }
    private async Task < IEnumerable < Employee >> GetCachedResponse(string cacheKey, SemaphoreSlim semaphore) {
        bool isAvaiable = _cache.TryGetValue(cacheKey, out List < Employee > employees);
        if (isAvaiable) return employees;
        try {
            await semaphore.WaitAsync();
            isAvaiable = _cache.TryGetValue(cacheKey, out employees);
            if (isAvaiable) return employees;
            employees = EmployeeService.GetEmployeesDeatilsFromDB();
            var cacheEntryOptions = new MemoryCacheEntryOptions {
                AbsoluteExpiration = DateTime.Now.AddMinutes(5),
                    SlidingExpiration = TimeSpan.FromMinutes(2),
                    Size = 1024,
            };
            _cache.Set(cacheKey, employees, cacheEntryOptions);
        } catch {
            throw;
        } finally {
            semaphore.Release();
        }
        return employees;
    }
}

Explanation of the code

First, we are checking if the cache has value or not.

bool isAvailable = _cache.TryGetValue(cacheKey, out List<Employee> employees);

if (isAvailable)
	return employees;

If the value is available in the cache, then get the value from the cache and send a response to the user else, then asynchronously wait to enter the Semaphore.

await semaphore.WaitAsync();

Once a thread has been granted access to the Semaphore, recheck if the value has been populated previously for safety (Avoid concurrent thread access).

isAvailable = _cache.TryGetValue(cacheKey, out employees);

if (isAvailable)
	return employees;

Still doesn’t have a value in the cache, then call the database and store the value in the cache.

employees = EmployeeService.GetEmployeesDeatilsFromDB();

var cacheEntryOptions = new MemoryCacheEntryOptions
{
	AbsoluteExpiration = DateTime.Now.AddMinutes(5),
	SlidingExpiration = TimeSpan.FromMinutes(2),
	Size = 1024,
};

_cache.Set(cacheKey, employees, cacheEntryOptions);

Send a response to the user.

Summary

In this article, we have learned the following functionality using .NET Core Web API.

• What is Caching,
• Types of Caching mechanism
• Detail about In-Memory Caching
• Implementing In-Memory Caching in ASP.NET Core Web API.