How to Implement In Memory Caching in .net

 

Introduction

In modern web applications, performance is key. Fetching data repeatedly from a database can lead to increased response times and higher server load. One effective way to optimize performance is by using in-memory caching to store frequently accessed data. In this blog, we will explore how to integrate IMemoryCache in an ASP.NET Core Web API project to efficiently handle CRUD operations for a Student entity.

What is In-Memory Caching?

In-memory caching is a mechanism that temporarily stores frequently accessed data in memory, reducing the need to retrieve it from the database each time. ASP.NET Core provides IMemoryCache, which is a simple, high-performance, and thread-safe cache.

Setting Up the Project

To demonstrate in-memory caching, let’s build an ASP.NET Core Web API with a StudentController that performs CRUD operations using Entity Framework Core.

1. Install Required Dependencies

Ensure you have the necessary NuGet packages installed in your ASP.NET Core project:

2. Add Model and  AppDb Context file

Student Model

namespace InMemoryCachePOC.Models { public class Student { public int Id { get; set; } public string Name { get; set; } public string Department { get; set; } public string City { get; set; } } }

AppDb Context File

using Microsoft.EntityFrameworkCore; namespace InMemoryCachePOC.Models { // public class AppDb: DbContext { public AppDb( DbContextOptions<AppDb> options) : base(options) { } public DbSet<Student> Students { get; set; } } }

3. Add in Appsettings.json just below of AllowedHosts by put comma

Connection String

"ConnectionStrings": { "DefaultConnection": "Server=.;Database=InMemoryCachePOC;Trusted_Connection=True;TrustServerCertificate=True;" }

4. Add Settings

Program.cs

builder.Services.AddMemoryCache(); builder.Services.AddDbContext<AppDb>(o=>o.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

5. Add-Migration and Update-database run two commands

6. add Controller with name Student

Student Controller

using InMemoryCachePOC.Models; using Microsoft.AspNetCore.Mvc; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Caching.Memory; namespace InMemoryCachePOC.Controllers { [Route("api/[controller]")] [ApiController] public class StudentController : ControllerBase { private readonly AppDb _context; private readonly IMemoryCache _cache; private readonly ILogger<StudentController> _logger; private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1); private const string CacheKey = "students_cache"; // Cache Key Constant public StudentController(AppDb context, IMemoryCache cache, ILogger<StudentController> logger) { _context = context; _cache = cache; _logger = logger; } /// <summary> /// Fetch all students with caching /// </summary> [HttpGet] public async Task<IActionResult> GetAll() { if (_cache.TryGetValue(CacheKey, out List<Student>? students)) { _logger.LogInformation("Data retrieved from cache."); return Ok(students); } try { await _semaphore.WaitAsync(); // Check cache again after acquiring lock to prevent multiple DB calls if (_cache.TryGetValue(CacheKey, out students)) { _logger.LogInformation("Data retrieved from cache after acquiring lock."); return Ok(students); } _logger.LogInformation("Fetching data from database."); students = await _context.Students.AsNoTracking().ToListAsync(); // Set cache options var cacheOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(10)) .SetAbsoluteExpiration(TimeSpan.FromHours(1)) .SetPriority(CacheItemPriority.High); _cache.Set(CacheKey, students, cacheOptions); _logger.LogInformation("Data cached successfully."); } finally { _semaphore.Release(); } return Ok(students); } /// <summary> /// Fetch student by ID with caching /// </summary> [HttpGet("{id}")] public async Task<IActionResult> GetById(int id) { var students = await GetCachedStudents(); var student = students.FirstOrDefault(s => s.Id == id); if (student == null) { _logger.LogWarning($"Student with ID {id} not found."); return NotFound("Student not found."); } return Ok(student); } /// <summary> /// Create a new student and update cache /// </summary> [HttpPost] public async Task<IActionResult> Create([FromBody] Student student) { if (student == null) return BadRequest("Invalid data."); await _context.Students.AddAsync(student); await _context.SaveChangesAsync(); _logger.LogInformation($"Student {student.Name} added successfully."); // Update cache await UpdateCache(); return CreatedAtAction(nameof(GetById), new { id = student.Id }, student); } /// <summary> /// Update an existing student and refresh cache /// </summary> [HttpPut("{id}")] public async Task<IActionResult> Update(int id, [FromBody] Student student) { if (student == null) return BadRequest("Invalid data."); var existingStudent = await _context.Students.FindAsync(id); if (existingStudent == null) return NotFound("Student not found."); existingStudent.Name = student.Name; existingStudent.Department = student.Department; existingStudent.City = student.City; _context.Students.Update(existingStudent); await _context.SaveChangesAsync(); _logger.LogInformation($"Student with ID {id} updated successfully."); // Update cache await UpdateCache(); return Ok(existingStudent); } /// <summary> /// Delete a student and refresh cache /// </summary> [HttpDelete("{id}")] public async Task<IActionResult> Delete(int id) { var student = await _context.Students.FindAsync(id); if (student == null) return NotFound("Student not found."); _context.Students.Remove(student); await _context.SaveChangesAsync(); _logger.LogInformation($"Student with ID {id} deleted successfully."); // Update cache await UpdateCache(); return NoContent(); } /// <summary> /// Get cached students /// </summary> private async Task<List<Student>> GetCachedStudents() { if (_cache.TryGetValue(CacheKey, out List<Student>? students)) { return students!; } students = await _context.Students.AsNoTracking().ToListAsync(); var cacheOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(10))// it expires after 10 minutes of inactivity .SetAbsoluteExpiration(TimeSpan.FromHours(1))// it expires after 1 hour .SetPriority(CacheItemPriority.High); _cache.Set(CacheKey, students, cacheOptions); return students; } /// <summary> /// Update cache after any CRUD operation /// </summary> private async Task UpdateCache() { _cache.Remove(CacheKey); var students = await _context.Students.AsNoTracking().ToListAsync(); var cacheOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(10)) .SetAbsoluteExpiration(TimeSpan.FromHours(1)) .SetPriority(CacheItemPriority.High); _cache.Set(CacheKey, students, cacheOptions); _logger.LogInformation("Cache updated after CRUD operation."); } } }

6. SetSlidingExpiration: refreseh if no activity in 10 min
SetAbsoluteExpiration : always refresh after 1 hour

Expalin memory Cache options

var cacheOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(10)) // refreseh if no activity in 10 min .SetAbsoluteExpiration(TimeSpan.FromHours(1)) // always refresh after 1 hour .SetPriority(CacheItemPriority.High);

Note: In this i used semaphoreslim for single process optimised the in memory cache. I am updating the in memory cache when add and update and delete. also this approch is helpfull for single server or small level applications. for multiserver or high level application we should go with distributed cache technique like redis so our ram not effected to much.

Clone this poc:InMemoryCachePOC