In Memory Cache in ASP.NET Core

Introduction

In most cases, applications need to read data to and from the data store, and reading data from the database for each request is costly, especially if the data changes infrequently. In Memory Cache in ASP.NET Core is a technique for storing data that is accessed frequently in the application by making a copy and storing that copy in a temporary location for quick access in the future to improve application performance and scalability.

In this post we will discover In Memory Cache in ASP.NET Core and in the next post we will create In Memory Cache Service.

Agenda

Commonly used cache platforms in ASP.NET CORE

Create and populate Databsae
Create an ASP.NET Core Web API
Implementing an In-Memory Cache in ASP.NET Core App

Configuring the Cache Options MemoryCacheEntryOptions.
Creating a custom cache service

Commonly used cache platforms in ASP.NET CORE

ASP.NET Core supports two types of caching:

In-memory cache: The cache data is stored in the application server’s memory. It’s the simplest form of cache that depends on the IMemoryCache interface, which is a cache object stored in the webserver’s application memory
Distributed cache: The cache data is stored on an external service that can be accessed by multiple application servers

Create and populate Database

1. Use SQL Server Management Studio or another SQL Server administrator.

2. Create an CS-Employee-Database database, then run the CS-<b>Employee-Database.sql</b> script that you can find in the project repository.

In Memory Cache in ASP.NET Core, in memory cache, in memory cache c#

Create an ASP.NET Core Web API

1. Create an ASP.NET Core Web API project using Visual Studio or using .NET Core CLI (Command Line Interface) with the name <strong>CS.MemoryCache.WebApi</strong> ,I will be using .NET Core CLI.

Here is the command I ran to create the web API:

dotnet new webapi --output CS.KeyVault.ApiApp --framework "net7.0" --use-program-main

2. Install the following NuGet package:

Microsoft.EntityFrameworkCore

Microsoft.EntityFrameworkCore.SqlServer

3. Create a new project folder named Entities and add a class file named Employee

namespace CS.MemoryCache.WebApi.Entities
{
    public class Employee
    {
        public int EmployeeId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Job { get; set; }
        public int Salary { get; set; }
        public DateTime HireDate { get; set; }
        public int? Manager { get; set; }
    }
}

4. Adding a Configuration Setting in the appsettings.json.

"ConnectionStrings": {
    "EmployeeConnection": "Server=(localdb)\MSSQLLocalDB;Database=CS-Employee-Database;Trusted_Connection=True;MultipleActiveResultSets=true"
}

5. Create a new project folder named Services and a subfolder named Interfaces.

6. Add a class file named EmployeeDbContext to the Services folder that derives from DbContext as shown below.

namespace CS.MemoryCache.WebApi.Services
{
    public class EmployeeDbContext : DbContext
    {
        public EmployeeDbContext(DbContextOptions<EmployeeDbContext> options) :
            base(options)
        {
        }
        public DbSet<Employee> Employees { get; set; }
    }
}

7. Add the folowing code to configure Entity Framework Core in the Program.cs.

var configuration = builder.Configuration;
builder.Services.AddDbContext<EmployeeDbContext>(options => options.UseSqlServer(configuration.GetConnectionString("EmployeeConnection")));

8. Add an interface named IEmployeeService to the Interfaces subfolder that contains a method that retrieves a list of Employee objects from the database.

namespace CS.MemoryCache.WebApi.Services.Interfaces
{
    public interface IEmployeeService
    {
        Task<IEnumerable<Employee>> GetEmployees();
    }
}

9. Add a class file named EmployeeService to the Services folder that implements the above interface.

public class EmployeeService : IEmployeeService
{
    private readonly EmployeeDbContext employeeDbContext;
    public EmployeeService(EmployeeDbContext employeeDbContext)
    {
        this.employeeDbContext = employeeDbContext;
    }
    public async Task<IEnumerable<Employee>> GetEmployees()
    {
       return await employeeDbContext.Employees.ToListAsync();
    }
}

10.We use Dependency Injection to register the service in the Program.cs as shown below.

builder.Services.AddScoped<IEmployeeService, EmployeeService>();

11. Create a controller named EmployeeController and add the following method that returns a list of Employee objects (see below)

namespace CS.MemoryCache.WebApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        private readonly IEmployeeService employeeService;
        public EmployeeController(IEmployeeService employeeService)
        {
            this.employeeService = employeeService;
        }   
       [HttpGet("employees")]
       public async Task<IEnumerable<Employee>> GelAllEmployees()
        {
            return await employeeService.GetEmployees();
        }
    }
}

The project at this point should look like this:

Also read https://dotnetcoder.com/building-a-reusable-blazor-select-component/

Implementing an In-Memory Cache in ASP.NET Core App

To configure memory caching, we need to update the Program.cs.

1. The following code adds the MemoryCache class to the Dependency Injection container which is a built-in implementation of IMemoryCache

builder.Services.AddMemoryCache();

2. Update the EmployeeController to receive an instance of the MemoryCache class using constructor injection.

namespace CS.MemoryCache.WebApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        private readonly IEmployeeService employeeService;
        private readonly IMemoryCache memoryCache;
        public EmployeeController(IMemoryCache memoryCache, IEmployeeService employeeService)
        {
            this.memoryCache = memoryCache;
            this.employeeService = employeeService;
        }
        [HttpGet("employees")]
        public async Task<IEnumerable<Employee>> GelAllEmployees()
        {
            return await employeeService.GetEmployees();
        }
    }
}

3. Run the application and call the controller action, and observe the output

4. MemoryCache exposes many methods, but the most important are Get to retrieve the item associated with a key, Set to insert an item, and Remove to remove an item.

The following code uses TryGetValue , if the cache is available we return the value, otherwise we query the database and store the value using the Set method.

namespace CS.MemoryCache.WebApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        private readonly IEmployeeService employeeService;
        private readonly IMemoryCache memoryCache;
        public EmployeeController(IMemoryCache memoryCache, IEmployeeService employeeService)
        {
            this.memoryCache = memoryCache;
            this.employeeService = employeeService;
        }
        [HttpGet("employees")]
        public async Task<IEnumerable<Employee>> GelAllEmployees()
        {
            IEnumerable<Employee> cacheEmployees;
            if (!memoryCache.TryGetValue("cacheEmployees", out cacheEmployees))
            {
                cacheEmployees = await employeeService.GetEmployees();
                var cacheEntryOptions = new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(TimeSpan.FromSeconds(100))
                    .SetAbsoluteExpiration(TimeSpan.FromSeconds(200))
                    .SetPriority(CacheItemPriority.NeverRemove)
                    .SetSize(1024);
                memoryCache.Set("cacheEmployees", cacheEmployees, cacheEntryOptions);
            }
            memoryCache.TryGetValue("cacheEmployees", out cacheEmployees);
            return cacheEmployees;
        }
    }
}

We configured the in-memory caching behavior using the MemoryCacheEntryOptions object, which exposes several methods for configuring the caching behavior:

SetSlidingExpiration() to specify how long a cache entry can be inactive before it is removed.
SetAbsoluteExpiration() to remove the cache entry regardless of whether it is still active or not; the absolute expiration should always be greater than the sliding expiration.

SetPriority() to set the priority for a cache entry as the server tries to free up the memory, the priority of the cache entry is taken into account, by default the priority will be Normal
SetSize() to set a size limit for the cache memory.

5. Run the application and test it with Postman. Observe how long it takes for the API to respond.

Conclusion

In this post, we explained the basics of in-memory caching and how to implement it and configure its behaviour. In the next post, we will create a cache wrapper class that abstracts the core logic of caching.

The code for the demo can be found Here

Also read https://dotnetcoder.com/azure-service-bus-integration-with-asp-net-core-web-api/

Enjoy This Blog?