Cache-Apart Sample Utilizing ASP.NET Core And Azure Redis Cache

Within the software program improvement cycle, typically the main target is on the efficiency of the appliance. There are a lot of methods to enhance the efficiency and one of the crucial generally used patterns to enhance the efficiency in fashionable cloud functions is the cache-aside sample. On this publish, I’ll describe briefly about cache-aside sample and its implementation utilizing ASP.NET Core.




This sample is pretty easy and its sole goal is to load knowledge on demand into the cache from the info supply. This helps in sustaining the consistency between the info within the cache and its underlying knowledge supply.


Following are the traits of the sample

  • When an utility wants knowledge, first it can look into cache
  • In case the info is current within the cache, then the appliance will use the info from the cache.
  • In any other case knowledge will likely be retrieved from the info supply.

The under is the diagrammatic illustration

The cache object must be invalidated upon adjustments within the worth by the appliance.



The order of invalidating the cache is vital. Replace the info supply earlier than eradicating the merchandise from the cache. In case, you eliminated the merchandise from the cache first, there are possibilities the consumer may fetch the merchandise earlier than the info retailer is up to date. That can lead to knowledge inconsistency between knowledge retailer and cache.


When to make use of this sample

  • This sample permits us to load knowledge on demand and can be utilized when the useful resource demand is unpredictable
  • A cache that does not present read-through and write-through operations.

Be aware

  • Learn-By means of: It is a cache that sits in-line with the database and in case of cache miss, it may possibly load the info from the database and populate the cache.
  • Write-By means of: The cache sits in-line with the database and knowledge at all times goes via the cache to the primary database.

Create Azure Assets


As illustrated above, we’d like the database (Azure SQL Server) and Cache (Azure Redis Cache). You’ll be able to select the database and cache of your comfort.

  1. $resourceGroup=“<Useful resource Group>”  
  2. $location=“<location>”  
  3. $redisCacheName=“<Redis cache title>”  
  4. $sqlServerName=“<Azure SQL Server Identify>”  
  5. $sqlDBName=“<Azure SQL DB Identify>”  
  6. $adminName=“<admin title of SQL server>”  
  7. $adminPassword=“<admin password of SQL Server>”  
  9. //Creating a useful resource group  
  10. az group create –name $resourceGroup –location $location  
  12. //Create Redis Cache with SKU as Fundamental  
  13. az redis create –name $redisCacheName –resource-group $resourceGroup –location $location –sku Fundamental –vm-size c0  
  15. //Create SQL Server  
  16. az sql server create -l $location -g $resourceGroup -n $sqlServerName -u $adminName -p $adminPassword  
  18. //Create SQL database with SKU as Fundamental  
  19. az sql db create -g $resourceGroup -s $sqlServerName -n $sqlDBName –service-objective Fundamental  



Let’s start with the implementation by creating an ASP.NET Core Internet API challenge and add nuget packages required for Redis cache and Entity Framework Core.

  1. dotnet add bundle Microsoft.EntityFrameworkCore.SqlServer  
  2. dotnet add bundle Microsoft.EntityFrameworkCore.Instruments  
  3. dotnet add bundle Microsoft.Extensions.Caching.StackExchangeRedis  

Firstly, let’s create a rustic mannequin class.

  1. public class Nation  
  2.     {  
  3.         public int Id { getset; }  
  4.         public string Identify { getset; }  
  5.         public bool IsActive { getset; }  
  6.     }  

Now, let’s register the dependencies of EF Core and Redis cache in ConfigureServices methodology of Startup class.

  1. public void ConfigureServices(IServiceCollection providers)  
  2.         {  
  3.             providers.AddControllers();  
  4.             providers.AddDbContext<CountryContext>(optionsAction =>   
  5.                   optionsAction.UseSqlServer(Configuration.GetConnectionString(“DefaultConnection”)));  
  7.             providers.AddStackExchangeRedisCache(setupAction =>  
  8.             {  
  9.                 setupAction.Configuration= Configuration.GetConnectionString(“RedisConnectionString”);  
  10.             });  
  11.         }  

Now modify the appsettings.json file to accommodate the connectionstrings of Redis Cache and SQL Database

  1. “ConnectionStrings”: {  
  2.     “RedisConnectionString”“<Redis Cache ConnectionString>”,  
  3.     “DefaultConnection”“<SQL Server Connection string>”  
  4.   }  

Let’s add DbContext class

  1. public class CountryContext:DbContext  
  2.     {  
  3.         public DbSet<Nation> Nations { getset; }  
  4.         public CountryContext(DbContextOptions dbContextOptions):base(dbContextOptions)  
  5.         {  
  6.         }  
  7.     }  

The GetCountries methodology tries to retrieve an merchandise from the cache utilizing a key. If the match is discovered , it is returned. In any other case the info will likely be retrieved from the database and populate it to the cache. The cached merchandise is configured to run out after 5 minutes.

  1. [Route(“api/[controller]”)]  
  2.     [ApiController]  
  3.     public class CountryController : ControllerBase  
  4.     {  
  5.         non-public readonly IDistributedCache cache;  
  6.         non-public readonly CountryContext countryContext;  
  8.         public CountryController(IDistributedCache cache,CountryContext countryContext)  
  9.         {  
  10.             this.cache = cache;  
  11.             this.countryContext = countryContext;  
  12.         }  
  15.         [HttpGet]  
  16.         public async Job< IEnumerable<Nation>> GetCountries()  
  17.         {  
  18.             var countriesCache = await cache.GetStringAsync(“nations”);  
  19.             var worth= (countriesCache == null)? default  
  20.                 : JsonConvert.DeserializeObject<IEnumerable< Nation>>(countriesCache);  
  21.             if (worth == null)  
  22.             {  
  23.                 var nations=countryContext.Nations.ToList();  
  24.                 if(nations!=null && nations.Any())  
  25.                 {  
  26.                     await cache.SetStringAsync(“Nations”, JsonConvert.SerializeObject(nations), new DistributedCacheEntryOptions  
  27.                     {  
  28.                         AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)  
  29.                     });  
  30.                     return nations;  
  31.                 }  
  32.             }  
  33.             return worth;  
  34.         }  
  35. }  

The AddCountries methodology illustrates how the cache could be invalidated upon including/updating the info to the database.

  2.         [HttpPost]  
  3.         public async Job<ActionResult<string>> AddCountries([FromBody] Nation nation, CancellationToken cancellationToken)  
  4.         {  
  5.             if (nation == null)  
  6.                 return BadRequest(“nation is null”);  
  8.             await countryContext.AddAsync(nation);  
  9.             await countryContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);  
  10.             await cache.RemoveAsync(“nations”, cancellationToken).ConfigureAwait(false);  
  11.             return Okay(“cache has been invalidated”);  
  12.         }  



On this article, I described Cache-Apart sample and its main implementation utilizing ASP.NET Core and Azure Redis Cache. Pleased Caching!


I hope you just like the article. In case you discover the article fascinating then kindly like and share it.

Show More

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *