Distributed Caching

When your cached data is distributed, the data is consistent across server restarts and application deployments. The IDistributedcache interface pertaining to Microsoft.Extensions.Caching.Distributed namespace represents a distributed cache. To manipulate the data stored in the distributed cache, you can use the following methods:

• Get or GetAsync: To retrieve items from the distributed cache based on its key
• Set or SetAsync: To store items into the distributed cache
• Refresh or RefreshAsync: To refresh an item in the distributed cache
• Remove or RemoveAsync: To delete an item from the distributed cache based on its key

Step for download the Redis-server.exe

• Download the ZIP Folder from this Github Repo. You could also use the MSI Executable. OR you download the running code and  the redis-server.exe file from pay and download at the top of the blog 
• The database script file is also in the folder 

"https://github.com/microsoftarchive/redis/releases/tag/win-3.0.504"

• Extract the Zip Folder and Open up redis-server.exe. That’s it, The Redis Server is now running on your machine. DO NOT CLOSE this Window.

First, let’s install a package that helps you communicate with the Redis server.

https://www.nuget.org/packages/Microsoft.Extensions.Caching.StackExchangeRedis

NuGet\Install-Package Microsoft.Extensions.Caching.StackExchangeRedis -Version 7.0.0

After setting up our local database, we need to update the appsettings.json file

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=DESKTOP-K2Q2EAS; Database=DbEmployee; Trusted_Connection=True; MultipleActiveResultSets=true"
  },
  "RedisCacheServerUrl": "127.0.0.1:6379",
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

Create a new file called Product.cs and write the following code in there:

namespace RedisCache.Models
{
    public class Product
    {
        public int ProductID { get; set; }

        public string ProductCategory{ get; set; }
       
        public string SubCategory { get; set; }
        
        public string ProductName { get; set; }
      
        public string ProductDescription { get; set; }

        public decimal ProductPrice { get; set; }
 
        public decimal ProductWeight { get; set; }
 
        public int Units { get; set; }
 
        public decimal Total { get; set; }
 
    }
}

Create class DbEmployeeContext

using Microsoft.EntityFrameworkCore;

namespace RedisCache.Models
{
    public class DbEmployeeContext : DbContext
    {
        public DbEmployeeContext(DbContextOptions<DbEmployeeContext> options)
            : base(options)
        {
        }

        public DbSet<Product> Products { get; set; }
    }
}

You can use the following code snippet to specify the Redis connection string in the Program class.

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddControllersWithViews();

            services.AddDbContext<DbEmployeeContext>(options =>options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            services.AddStackExchangeRedisCache(options =>
            {
                options.Configuration = Configuration["RedisCacheServerUrl"];
            });
        }

The ProductController Class

Create a new API controller class named ProductController

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Distributed;
using Newtonsoft.Json;
using RedisCache.Models;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

namespace RedisCache.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        private readonly DbEmployeeContext _context;
        private readonly IDistributedCache _cache;

        public ProductController(DbEmployeeContext context, IDistributedCache cache)
        {
            _context = context;
            _cache = cache;
        }

        [HttpGet]
        public async Task<IActionResult> GetAll()
        {
            var products = await _context.Products.ToListAsync();

            return Ok(products);
        }

        [HttpGet]
        [Route("/GetAllByRedis")]
        public async Task<IActionResult> GetAllByRedis()
        {
            var cacheKey = "GET_ALL_PRODUCTS";
            List<Product> products = new List<Product>();

            // Get data from cache
            var cachedData = await _cache.GetAsync(cacheKey);
            if (cachedData != null)
            {
                // If data found in cache, encode and deserialize cached data
                var cachedDataString = Encoding.UTF8.GetString(cachedData);
                products = JsonConvert.DeserializeObject<List<Product>>(cachedDataString);
            }
            else
            {
                // If not found, then fetch data from database
                products = await _context.Products.ToListAsync();

                // serialize data
                var cachedDataString = JsonConvert.SerializeObject(products);
                var newDataToCache = Encoding.UTF8.GetBytes(cachedDataString);

                // set cache options 
                var options = new DistributedCacheEntryOptions()
                    .SetAbsoluteExpiration(DateTime.Now.AddMinutes(2))
                    .SetSlidingExpiration(TimeSpan.FromMinutes(1));

                // Add data in cache
                await _cache.SetAsync(cacheKey, newDataToCache, options);
            }

            return Ok(products);
        }
    }
}

Open up postman and send a GET request to "https://localhost:44386/api/product"

Open up postman and send a GET request to "https://localhost:44386/GetAllByRedis"