Asp.Net Core Distrubuted Redis Cache

view raw 1.docker hosted with ❤ by GitHub



	Install-Package Microsoft.Extensions.Caching.StackExchangeRedis

view raw 2.Nugget hosted with ❤ by GitHub

	{
	"Logging": {
	"LogLevel": {
	"Default": "Information",
	"Microsoft.AspNetCore": "Warning"
	}
	},
	"Redis": {
	"ConnectionString": "localhost:6379"
	},
	"AllowedHosts": "*"
	}

view raw 3.appsettings.json hosted with ❤ by GitHub

	using Microsoft.Extensions.Caching.Distributed;
	using System.Text.Json;

	namespace CacheUse.Infrastructure
	{
	public interface ICacheProvider
	{
	Task<T> GetFromCacheAsync<T>(string key) where T:class;
	Task SetCacheAsync<T>(string key, T value) where T : class;

	}
	public class CacheProvider : ICacheProvider
	{
	DistributedCacheEntryOptions options = new DistributedCacheEntryOptions()
	{
	SlidingExpiration = TimeSpan.FromSeconds(30)
	};

	private readonly IDistributedCache distrubutedCache;
	public CacheProvider(IDistributedCache distrubutedCache)
	{
	this.distrubutedCache = distrubutedCache;
	}

	public async Task<T> GetFromCacheAsync<T>(string key) where T : class
	{
	var cachedValue = await distrubutedCache.GetStringAsync(key);
	return cachedValue == null ? null : JsonSerializer.Deserialize<T>(cachedValue);
	}

	public async Task SetCacheAsync<T>(string key, T value) where T : class
	{
	var cacheValue = JsonSerializer.Serialize(value);
	await distrubutedCache.SetStringAsync(key, cacheValue, options);
	}
	}
	}

view raw 4.CacheProvider.cs hosted with ❤ by GitHub

	using CacheUse.Infrastructure;
	using Microsoft.Extensions.Caching.Distributed;
	using System.Text.Json;

	namespace CacheUse.Services
	{
	public interface IDistrubutedCacheService
	{
	Task<T> GetAsync<T>(string key) where T : class;
	Task SetAsync<T>(string key,T value) where T : class;
	}
	public class DistrubutedCacheService : IDistrubutedCacheService
	{
	private readonly ICacheProvider cacheProvider;

	public DistrubutedCacheService(ICacheProvider cacheProvider)
	{
	this.cacheProvider = cacheProvider;
	}
	public async Task<T> GetAsync<T>(string key) where T: class
	{
	return await cacheProvider.GetFromCacheAsync<T>(key);
	}

	public async Task SetAsync<T>(string key, T value) where T: class
	{
	await cacheProvider.SetCacheAsync<T>(key, value);
	}
	}
	}




	private readonly ILogger<WeatherForecastController> _logger;
	private readonly IDistrubutedCacheService distrubutedCacheService;

	public WeatherForecastController(ILogger<WeatherForecastController> logger , IDistrubutedCacheService distrubutedCacheService)
	{
	_logger = logger;
	this.distrubutedCacheService = distrubutedCacheService;
	}

	[HttpGet("{GetRedisCache}")]
	public async Task<IEnumerable<WeatherForecast>> GetRedisCache()
	{
	var key = "weatherForecastList";
	IEnumerable<WeatherForecast>? weatherForecastList =null;

	weatherForecastList = await distrubutedCacheService.GetAsync<IEnumerable<WeatherForecast>>(key);

	if (weatherForecastList != null)
	{
	Console.WriteLine("weatherForecastList from Redis Cache ");

	}
	else
	{
	Console.WriteLine("weatherForecastList Not Exists in Redis Cache ");
	weatherForecastList = Enumerable.Range(1, 5).Select(
	index => new WeatherForecast
	{
	Date = DateTime.Now.AddDays(index),
	TemperatureC = Random.Shared.Next(-20, 55),
	Summary = Summaries[Random.Shared.Next(Summaries.Length)]
	}
	);


	await distrubutedCacheService.SetAsync<IEnumerable<WeatherForecast>>(key, weatherForecastList);
	Console.WriteLine("weatherForecastList added Cache");
	}


	return weatherForecastList;
	}

	builder.Services.AddStackExchangeRedisCache(o =>
	{
	o.Configuration = builder.Configuration.GetSection("Redis")["ConnectionString"]; //"localhost";
	o.InstanceName = "SampleInstance";
	});

	builder.Services.AddScoped<ICacheProvider, CacheProvider>();
	builder.Services.AddScoped<IDistrubutedCacheService, DistrubutedCacheService>();

view raw 7.Program.cs hosted with ❤ by GitHub

	OUTPUT:

	weatherForecastList Not Exists in Redis Cache
	weatherForecastList added Cache
	weatherForecastList from Redis Cache

view raw 8.Output hosted with ❤ by GitHub

Gökhanb