Implementation Of The Redis Cache In The .NET Core API

using Microsoft.AspNetCore.Mvc;
using RedisCacheDemo.Cache;
using RedisCacheDemo.Data;
using RedisCacheDemo.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace RedisCacheDemo.Controllers {
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController: ControllerBase {
        private readonly DbContextClass _dbContext;
        private readonly ICacheService _cacheService;
        public ProductController(DbContextClass dbContext, ICacheService cacheService) {
                _dbContext = dbContext;
                _cacheService = cacheService;
            }
            [HttpGet("products")]
        public IEnumerable < Product > Get() {
                var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
                if (cacheData != null) {
                    return cacheData;
                }
                var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
                cacheData = _dbContext.Products.ToList();
                _cacheService.SetData < IEnumerable < Product >> ("product", cacheData, expirationTime);
                return cacheData;
            }
            [HttpGet("product")]
        public Product Get(int id) {
                Product filteredData;
                var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
                if (cacheData != null) {
                    filteredData = cacheData.Where(x => x.ProductId == id).FirstOrDefault();
                    return filteredData;
                }
                filteredData = _dbContext.Products.Where(x => x.ProductId == id).FirstOrDefault();
                return filteredData;
            }
            [HttpPost("addproduct")]
        public async Task < Product > Post(Product value) {
                var obj = await _dbContext.Products.AddAsync(value);
                _cacheService.RemoveData("product");
                _dbContext.SaveChanges();
                return obj.Entity;
            }
            [HttpPut("updateproduct")]
        public void Put(Product product) {
                _dbContext.Products.Update(product);
                _cacheService.RemoveData("product");
                _dbContext.SaveChanges();
            }
            [HttpDelete("deleteproduct")]
        public void Delete(int Id) {
            var filteredData = _dbContext.Products.Where(x => x.ProductId == Id).FirstOrDefault();
            _dbContext.Remove(filteredData);
            _cacheService.RemoveData("product");
            _dbContext.SaveChanges();
        }
    }
}

Step 7. Add the SQL Server connection string and Redis URL inside appsetting.json.

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        }
    },
    "AllowedHosts": "*",
    "RedisURL": "127.0.0.1:6379",
    "ConnectionStrings": {
        "DefaultConnection": "Data Source=Server;Initial Catalog=RedisCache;User Id=sa;Password=***;"
    }
}

Step 8. Next, Register the ICacheService inside the Configure Service method of Startup Class and also add some configuration related to Swagger to test our API endpoints.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using RedisCacheDemo.Cache;
using RedisCacheDemo.Data;
namespace RedisCacheDemo {
    public class Startup {
        public Startup(IConfiguration configuration) {
            Configuration = configuration;
        }
        public IConfiguration Configuration {
            get;
        }
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services) {
            services.AddControllers();
            services.AddScoped < ICacheService, CacheService > ();
            services.AddDbContext < DbContextClass > (options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            services.AddSwaggerGen(c => {
                c.SwaggerDoc("v1", new OpenApiInfo {
                    Title = "RedisCacheDemo", Version = "v1"
                });
            });
        }
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
            if (env.IsDevelopment()) {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "RedisCacheDemo v1"));
            }
            app.UseHttpsRedirection();
            app.UseRouting();
            app.UseAuthorization();
            app.UseEndpoints(endpoints => {
                endpoints.MapControllers();
            });
        }
    }
}

Step 9. Create one ConfigurationManger Class to configure app setting over there

using Microsoft.Extensions.Configuration;
using System.IO;
namespace RedisCacheDemo {
    static class ConfigurationManager {
        public static IConfiguration AppSetting {
            get;
        }
        static ConfigurationManager() {
            AppSetting = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json").Build();
        }
    }
}

Step 10. Next, Create a Connection Helper Class for Redis Connection.

using StackExchange.Redis;
using System;
namespace RedisCacheDemo.Cache {
    public class ConnectionHelper {
        static ConnectionHelper() {
            ConnectionHelper.lazyConnection = new Lazy < ConnectionMultiplexer > (() => {
                return ConnectionMultiplexer.Connect(ConfigurationManager.AppSetting["RedisURL"]);
            });
        }
        private static Lazy < ConnectionMultiplexer > lazyConnection;
        public static ConnectionMultiplexer Connection {
            get {
                return lazyConnection.Value;
            }
        }
    }
}

Step 11. Perform Migration and Database Updates for DB Creation using the following commands in the Package Manager Console.

add-migration “FirstMigration”
update-database

So, when you enter and execute this command, it will generate a few things related to migration and create the database inside SQL Server as you put inside Connection String in the appsetting.json

Step 12. Finally, run the application and add the data using swagger UI and then check how caching works inside products and product endpoint.

Basically, I added cache into the product and products endpoints in the controller; as you see, when the user wants to fetch data of all products, then firstly, it will check whether the data is present inside the Redis Cache or not and if it’s present inside the cache then return that data to the user, and if the data is not present inside the cache, then it will fetch the data from database and also, set that into the cache. So next time user will get that from the cache only and avoid hitting the database unnecessarily

Also, when the user wants to fetch data using the product ID, as you see in the controller in the product second endpoint, we fetch data from the cache of all products and then filter using the product ID. If that is present, we return to the user from the cache; if not, we fetch from the database and return to the user after applying the filter.

As you see inside the update, delete, and post endpoints of the Product Controller, we use the remove method to remove the product key data from the cache. There are many scenarios and uses of memory caches you can use according to your needs and requirements. I just want to introduce the basics of the Redis Cache and how it works inside the .NET Core that I covered here.

Also, there is one scenario you need to take care of while using caching. Suppose two users are using your application. Then the following scenarios will happen.

• When the first user sends the request to fetch the data of all products, the first request comes, and then it will check if the data is present inside the cache or not. If the data is present inside the cache, then it will fetch the data from the database and also set it to the cache.
• Meanwhile, the Second User sends the request to get the product details. What happened is that the request also hits the database before completing the first user’s request, and because of that second user also hits the database to fetch product details.
• So, there is one solution for this to use the Lock Mechanism as shown below

Create this private object of lock on top of the class.

private static object _lock = new object()

Next, Modify the Get method as I showed below.

public IEnumerable < Product > Get() {
    var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
    if (cacheData != null) {
        return cacheData;
    }
    lock(_lock) {
        var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
        cacheData = _dbContext.Products.ToList();
        _cacheService.SetData < IEnumerable < Product >> ("product", cacheData, expirationTime);
    }
    return cacheData;
}

So here, as you see, first, we check if the data is present inside the cache or not. If data is available, then return that. Next, if the value is not present in the Redis cache, then we apply the lock over there, and then the request is locked and entered into the section fetches the product details from the database and then also sets it to the cache and returns the data. So, what happens when the second user sends a request before the user’s request is complete? So, in that case, the second request is in the queue, and after completing the first user request, the second request comes into the picture

Also, you can see key details which already present inside Redis using Redis CLI, as shown below

So, here you can see there are many commands that provide us with information about keys that are present in the Redis Cache.

This is all about Redis Cache in .NET Core. I hope you understand things related to that.

Happy Coding!