In uno script precedente (https://www.aspitalia.com/script/1249/Sfruttare-Redis-Cache-ASP.NET-Core.aspx) ci siamo occupati del supporto alla cache distribuita in ASP.NET Core, e abbiamo visto come esista un provider che renda estremamente immediato l'utilizzo di Redis Cache.

Non sempre, però, abbiamo a disposizione un cluster di Redis Cache, per esempio perché la nostra azienda non è ancora pronta a sfruttare Microsoft Azure e siamo ancora in uno scenario on-premises. Tuttavia, magari, siamo comunque in un contesto di Web Farm, ossia abbiamo più server in load balancing che servono il nostro sito; o, ancora, vogliamo condividere la cache tra due applicazioni distinte, come un front-end e un sito di back office.

In tutti questi casi, una cache distribuita apporta ancora notevoli benefici prestazionali e, in assenza di Redis Cache, possiamo sfruttare un database SQL Server condiviso per memorizzarne le chiavi. Tipicamente, si tratterà di un database differente da quello in cui vengono memorizzati i dati applicativi veri e propri, così da non impattare nelle prestazioni di quest'ultimo e mantenere questi due componenti dell'infrastruttura ben distinti.

Il primo passo è quello di installare i due package NuGet necessari:

Install-Package Microsoft.Extensions.Caching.SqlServer
Install-Package Microsoft.Extensions.Caching.SqlConfig.Tools

Il primo contiene le vere e proprie librerie che andremo a utilizzare, mentre il secondo estende il tool a riga di comando DotNet CLI con un comando per creare la tabella sul database. Occupiamoci subito di quest'ultimo task, aprendo un prompt dei comandi e digitando:

dotnet sql-cache create "..connection string al database.." dbo CacheData

I tre parametri sono rispettivamente:

• la connection string per il database
• lo schema da utilizzare, nel nostro caso dbo
• il nome della tabella con le chiavi di cache

Il risultato sarà una nuova tabella nel database, come quella in figura:

A questo punto siamo pronti per configurare il provider di cache in ASP.NET Core. Come al solito, sfrutteremo il metodo ConfigureServices della classe Startup:

public void ConfigureServices(IServiceCollection services)
{
  // .. altre configuraiozioni qui  

  services.AddDistributedSqlServerCache(cfg => 
  {
    cfg.ConnectionString = Configuration.GetConnectionString("cachedb");
    cfg.SchemaName = "dbo";
    cfg.TableName = "CacheData";
  });
}

I parametri sono sostanzialmente gli stessi che abbiamo utilizzato in precedenza. Questo metodo inietta un nuovo provider per l'interfaccia IDistributedCache, che possiamo sfruttare in maniera assolutamente analoga a quanto visto nel caso di Redis Cache. Il codice per sfruttare la cache in un controller resta, infatti, esattamente il medesimo:

public class HomeController : Controller
{
  private IDistributedCache _cache;

  public HomeController(IDistributedCache cache)
  {
    _cache = cache;
  }

  public async Task<IActionResult> Index()
  {
    var currentDate = await _cache.GetStringAsync("currentDate");

    if (currentDate == null)
    {
      currentDate = DateTime.Now.ToString();
      await _cache.SetStringAsync("currentDate", currentDate, new DistributedCacheEntryOptions()
      {
         AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(10)
      });
    }
            
    ViewBag.CurrentDate = currentDate;
    return View();
  }
}

Si tratta di uno dei grandi vantaggi del programmare per astrazioni: l'implementazione concreta di IDistributedCache sarà sensibilmente differente, ma non dovremo effettuare alcuna manutenzione sul codice applicativo.