DevelopmentHelpers.AzureDistributedCache 8.0.0

DevelopmentHelpers.AzureDistributedCache

Overview

**DevelopmentHelpers.AzureDistributedCache is a library that simplifies access to Azure Redis Cache in .NET applications.

Installation

1. Add Configuration Settings to your appsettings.json file:

   {
     "DevelopmentHelpers" : {
      "AzureDistributedCacheConfiguration": {
     "DnsName": "--DNS--NAME",
     "ConnectionString": "-- Connection String --- "
     }
    }
   }  
   

2. Add the Development Helper Service

        builder.Services.AddAzureRedisCache(builder.Configuration);
   

Code Example

 public class IndexModel : PageModel
 {
     private readonly IDistributedCache cache;
     private const string cacheItem = "CacheTime";
     private readonly ILogger<IndexModel> _logger;

     public IndexModel(ILogger<IndexModel> logger, IDistributedCache cache)
     {

         this.cache = cache;
         _logger = logger;
     }

     public async Task OnGetAsync()
     {
         string value = await cache.GetStringAsync(cacheItem);
         if (value == null)
         {
             value = DateTime.Now.ToString();
             var options = new DistributedCacheEntryOptions();
             options.SetSlidingExpiration(TimeSpan.FromMinutes(10));
             await this.cache.SetStringAsync(cacheItem, value, options);
         }

         ViewData[cacheItem] = value;

         ViewData["CurrentTime"] = DateTime.Now.ToString();
     }
 }

Motivation

I needed a consistent and easy to use library in .net application.

API Reference

IDistributedCache Interface

The IDistributedCache interface is used to perform distributed caching operations in .NET. Below are some of its key methods:

• GetStringAsync:

  Task<string> GetStringAsync(string key);
  

• SetStringAsync:

  Task SetStringAsync(string key, string value, DistributedCacheEntryOptions options);
  
  

• RemoveAsync:

  Task RemoveAsync(string key);
  
  

• SetStringAsync:

  Task SetStringAsync(string key, string value, DistributedCacheEntryOptions options);
  
  

• GetAsync:

  Task<byte[]> GetAsync(string ;
  
  

• SetStringAsync:

  Task SetStringAsync(string key, string value, DistributedCacheEntryOptions options);
  
  

• GetAsync:

  Task<byte[]> GetAsync(string key);
  
  

• SetAsync:

  Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options);
  
  

• RefreshAsync:

  Task RefreshAsync(string key);
  
  
  

• GetString:

  string GetString(string key);
  
  

• SetString:

  void SetString(string key, string value, DistributedCacheEntryOptions options);
  
  

• Get:

  byte[] Get(string key);
  
  

• Set:

  void Set(string key, byte[] value, DistributedCacheEntryOptions options);
  
  

• Remove:

  void Remove(string key);
  
  
  
  

Tests

[TestClass]
public class CacheTests
{

      [TestInitialize]
      public void TestInitialize()
      {

      }
      [DataTestMethod]
      public async Task SetRemoveAndGetStringCacheAsync()
      {
          IDistributedCache redisCache = (IDistributedCache)
              KernelMapper.ServiceProvider.GetService(typeof(IDistributedCache));
          string key = Guid.NewGuid().ToString();
          string value = DateTime.Now.ToString();
          var options = new DistributedCacheEntryOptions();
          options.SetSlidingExpiration(TimeSpan.FromMinutes(10));
          //Set the cache 
          await redisCache.SetStringAsync(key, value, options);
          var cacheValue = await redisCache.GetStringAsync(key);
          Assert.IsTrue(value.Equals(cacheValue, StringComparison.CurrentCultureIgnoreCase));

          await redisCache.RemoveAsync(key);
          var cacheValue2 = await redisCache.GetStringAsync($"{key}");
          Assert.IsTrue(cacheValue2 == null);
      }


      [DataTestMethod]
      [DataRow("quick brown fox jumps right over the lazy dog.")]
      public async Task SetAndGetByteCacheAsync(string dataItem)
      {
          IDistributedCache redisCache = (IDistributedCache)
              KernelMapper.ServiceProvider.GetService(typeof(IDistributedCache));
          string key = Guid.NewGuid().ToString();
          byte[] value = Encoding.ASCII.GetBytes(dataItem);
          var options = new DistributedCacheEntryOptions();
          options.SetSlidingExpiration(TimeSpan.FromMinutes(10));
          //Set the cache 
          await redisCache.SetAsync(key, value, options);
          byte[] cacheValue = await redisCache.GetAsync(key);

          Assert.IsTrue(dataItem.Equals(Encoding.ASCII.GetString(cacheValue),
              StringComparison.CurrentCultureIgnoreCase));


          await redisCache.RemoveAsync(key);
          var cacheValue2 = await redisCache.GetAsync($"{key}");
          Assert.IsTrue(cacheValue2 == null);
      }
}