Caching dei dati

• Pubblicato il
• 30/03/2011
• Autore
• Vincenzo Gaglio

Il caching dei dati è un utile strumento per il miglioramento delle prestazioni di qualsiasi sistema software. L’idea consiste nel porre i dati più frequentemente utilizzati in un dispositivo molto performante. Infatti sebbene il tempo di accesso alle periferiche di memorizzazione di massa continui a migliorare, accedere ai dati residenti ad esempio su un hard disk è ancora un’operazione molto più lenta che accedere ad essi mentre si trovano in memoria. Rendere quindi disponibili in modo rapido i dati più utilizzati contribuisce significativamente a migliorare le prestazioni delle nostre applicazioni.

In ASP.NET la Cache è parallela alle nostre applicazioni ed è disponibile attraverso HttpContext e System.Web.UI.Page. Utilizzare la Cache è molto simile a quanto visto per l’oggetto Session, poichè è possibile accedere agli oggetti contenuti in essa tramite un indicizzatore. In aggiunta è anche possibile controllare la durata degli oggetti ed impostare dei collegamenti tra gli oggetti in cache e i dati fisici di origine.

La gestione della cache in ASP.NET è estremamente semplice e per vedere come fare procediamo con un esempio. Supponiamo di avere un metodo GetData() che effettua una connessione ad un database e restituisce una datatable

protected DataTable GetData()
{
  DataTable dt = null;
  dt = new DataTable();
  string strConnection = "Stringa di connessione al DB";
  DbProviderFactory f =
  DbProviderFactories.GetFactory("System.Data.SqlClient");
  using (DbConnection conn = f.CreateConnection())
  {
    conn.ConnectionString = strConnection;
    conn.Open();
    DbCommand command = f.CreateCommand();
    command.CommandText = "Select * from NomeTabella";
    command.Connection = conn;
    IDataReader reader = command.ExecuteReader();
    dt.Load(reader);
    reader.Close();
    conn.Close();
  }
  return dt;
}

Abbiamo anche un altro metodo BindData() che associa i dati restituiti dal metodo GetData() ad una DataList presente in un nostro web form

protected DataTable BindData()
{
  DataTable dt;
  dt = this.GetData();
  this.DataList1.DataSource = dt;
  this.DataBind();
  return dt;
}

un altro metodo che ci serve per il nostro esempio è CreaTabella che restituisce la struttura di una tabella in base ad un determinato schema

protected DataTable CreaTabella(DataTable tableSchema)
{
  DataTable tabella = new DataTable();
  foreach (DataColumn dc in tableSchema.Columns)
  {
    tabella.Columns.Add(dc.ColumnName,
    dc.DataType);
  }
  return tabella;
}

I metodi GetData() e BindData() vengono chiamati nell’evento Page_Load nel modo seguente

protected void Page_Load(object sender, EventArgs e)
{
  if (!IsPostBack)
  {
    DataTable dt = BindData();
    DataTable elementiTabella = this.CreaTabella(dt);
    Session["elementiTabella"] = elementiTabella;
  }
}

A questo punto possiamo fare alcune valutazioni sulla natura dei dati gestiti dalla nostra applicazione. Domandandoci se è proprio necessario ricaricare tali dati ogni volta se essi non cambiano spesso. Se tale necessità non è presente possiamo pensare di memorizzare tali dati su un supporto che consenta un accesso agli stessi molto veloce e senza bisogno di connessioni al database (per esempio la memoria interna del computer). In questo modo l’applicazione potrebbe soddisfare molte più richieste contemporanee da parte dei client. Ovviamente se i dati trattati dalla nostra applicazione cambiassero molto spesso quest’approccio non sarebbe opportuno.

I passi per effettuare il caching dei dati sono:

1. Verificare se un determinato dato si trova in cache
2. Se è presente in cache utilizzarlo
3. Se non è presente in cache connettersi al database per ottenerlo
4. Memorizzare l’elemento appena caricato in cache per eventuali usi futuri

A questo punto andiamo a modificare i metodi che abbiamo visto nella parte iniziale della presente lezione per gestire il caching dei dati. Ecco il metodo GetData() modificato

protected DataTable GetData()
{
  DataTable dt = null;  
  dt = (DataTable)Cache["TabellaInCache"];  
  if (dt == null)
  {
    dt = new DataTable();
    string strConnection = "Stringa di connessione al DB";
    DbProviderFactory f = DbProviderFactories.GetFactory("System.Data.SqlClient");
    using (DbConnection conn = f.CreateConnection())
    {
      conn.ConnectionString = strConnection;
      conn.Open();
      DbCommand command = f.CreateCommand();
      command.CommandText = "Select * from NomeTabella";
      command.Connection = conn;
      IDataReader reader = command.ExecuteReader();
      dt.Load(reader);
      reader.Close();
      conn.Close();
    }
  }
  Cache["TabellaInCache"] = dt;
  return dt;
}

Nel nuovo metodo GetData() viene prima effettuato un controllo sull’esistenza della tabella in cache. Se la tabella non esiste if (dt == null) essa viene creata come veniva fatto in precedenza, ma se esiste la parte di connessione al database ed estrazione dei dati viene completamente bypassata. In ogni caso prima di restituire la tabella essa viene memorizzata in cache (Cache["TabellaInCache"] = dt;). Queste piccole modifiche riducono significativamente il costo del caricamento della pagina (se chiaramente è stata già creata una volta).

Chiaramente la presente lezione è volta a farvi intuire le potenzialità del caching dei dati e per approfondire le varie modalità di gestione della cache, i relativi metodi disponibili e capire quali di essi possono esservi utili di volta in volta vi invito a consultare la documentazione ufficiale Microsoft.