ASP.NET कोर और एज़्योर रेडिस कैश के साथ कैश-एसाइड पैटर्न को लागू करना

परिचय

• जब किसी एप्लिकेशन को डेटा की आवश्यकता होती है, तो सबसे पहले वह कैश को देखेगा।
• यदि डेटा कैश में मौजूद है, तो एप्लिकेशन कैश से डेटा का उपयोग करेगा।
• अन्यथा, डेटा को डेटा स्रोत से पुनर्प्राप्त किया जाएगा।

इस पैटर्न का उपयोग कब करें?

• यह पैटर्न हमें मांग पर डेटा लोड करने में सक्षम बनाता है और इसका उपयोग तब किया जा सकता है जब संसाधन की मांग अप्रत्याशित हो
• एक कैश जो रीड-थ्रू और राइट-थ्रू ऑपरेशन प्रदान नहीं करता है।

नोट

• पूरा पढ़ें: यह एक कैश है जो डेटाबेस के अनुरूप बैठता है और कैश मिस होने की स्थिति में, यह डेटाबेस से डेटा लोड कर सकता है और कैश को पॉप्युलेट कर सकता है।
• इसके माध्यम से लिखें: कैश डेटाबेस के अनुरूप बैठता है और डेटा हमेशा कैश के माध्यम से मुख्य डेटाबेस तक जाता है।

Azure संसाधन बनाएं

$resourceGroup="<Resource Group>"
$location="<location>"
$redisCacheName="<Redis cache name>"
$sqlServerName="<Azure SQL Server Name>"
$sqlDBName="<Azure SQL DB Name>"
$adminName="<admin name of SQL server>"
$adminPassword="<admin password of SQL Server>"
# Creating a resource group
az group create --name $resourceGroup --location $location
# Create Redis Cache with SKU as Basic
az redis create --name $redisCacheName --resource-group $resourceGroup --location $location --sku Basic --vm-size c0
# Create SQL Server
az sql server create -l $location -g $resourceGroup -n $sqlServerName -u $adminName -p $adminPassword
# Create SQL database with SKU as Basic
az sql db create -g $resourceGroup -s $sqlServerName -n $sqlDBName --service-objective Basic

कार्यान्वयन

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools
dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis

public class Country 
{ 
 public int Id { get; set; } 
 public string Name { get; set; } 
 public bool IsActive { get; set; } 
} 

public void ConfigureServices(IServiceCollection services)
{
 services.AddControllers();
 services.AddDbContext<CountryContext>(optionsAction =>
 optionsAction.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
 services.AddStackExchangeRedisCache(setupAction =>
 {
 setupAction.Configuration = Configuration.GetConnectionString("RedisConnectionString");
 });
}

"ConnectionStrings": {
 "RedisConnectionString": "<Redis Cache ConnectionString>",
 "DefaultConnection": "<SQL Server Connection string>"
}

public class CountryContext : DbContext
{
 public DbSet<Country> Countries { get; set; }
 public CountryContext(DbContextOptions dbContextOptions) : base(dbContextOptions)
 {
 }
}

[Route("api/[controller]")]
[ApiController]
public class CountryController : ControllerBase
{
 private readonly IDistributedCache cache;
 private readonly CountryContext countryContext;
 public CountryController(IDistributedCache cache, CountryContext countryContext)
 {
 this.cache = cache;
 this.countryContext = countryContext;
 }
 // GET: api/<CountryController>
 [HttpGet]
 public async Task<IEnumerable<Country>> GetCountries()
 {
 var countriesCache = await cache.GetStringAsync("countries");
 var value = (countriesCache == null) ? default : JsonConvert.DeserializeObject<IEnumerable<Country>>(countriesCache);
 if (value == null)
 {
 var countries = countryContext.Countries.ToList();
 if (countries != null && countries.Any())
 {
 await cache.SetStringAsync("Countries", JsonConvert.SerializeObject(countries), new DistributedCacheEntryOptions
 {
 AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
 });
 return countries;
 }
 }
 return value;
 }
}

// POST api/<CountryController>
[HttpPost]
public async Task<ActionResult<string>> AddCountries([FromBody] Country country, CancellationToken cancellationToken)
{
 if (country == null)
 return BadRequest("country is null");
 await countryContext.AddAsync(country);
 await countryContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
 await cache.RemoveAsync("countries", cancellationToken).ConfigureAwait(false);
 return Ok("cache has been invalidated");
}

निष्कर्ष