Caching dei dati
Il caching dei dati è un utile strumento per il miglioramento delle prestazioni di qualsiasi sistema software. Lidea 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 unoperazione 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 loggetto 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 nellevento 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;
}
}
e quindi ogni volta che la pagina viene creata viene effettuata la connessione al database e vengono ricaricati i dati. In un contesto in cui le richieste provengono da pochi client la cosa potrebbe essere accettabile, per applicazioni dimensionate per soddisfare le richieste di migliaia di client questo non è accettabile. Infatti le operazioni di accesso al database dono molto onerose a livello temporale e dovrebbero essere ridotte al minimo.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 lapplicazione potrebbe soddisfare molte più richieste contemporanee da parte dei client. Ovviamente se i dati trattati dalla nostra applicazione cambiassero molto spesso questapproccio non sarebbe opportuno.
I passi per effettuare il caching dei dati sono:
- Verificare se un determinato dato si trova in cache
- Se è presente in cache utilizzarlo
- Se non è presente in cache connettersi al database per ottenerlo
- Memorizzare lelemento 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 sullesistenza 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.