Come molti di voi sapranno le funzionalità per la gestione dello stato di un applicazione sono state implementate anche con ASP.NET.

Oltre agli oggetti Session e Application, dunque dalle funzionalità identiche alla controparte Classic ASP, è stato introdotto un nuovo oggetto, Cache, all'interno del namespace System.Web.Caching .

Le sue funzionalità base sono simili a quelle di Application: è possibile assegnare una coppia chiave/valore all'oggetto Cache e mantenerne il valore per l'intera vita dell'applicazione web, con un ambito di visibilità portato a tutti gli utenti.

Tuttavia questo oggetto presenta alcune nuove funzionalità molto utili rispetto ad Application:

• gestione del blocco di istruzioni. Con l'oggetto Application si presentava un problema molto importante relativo all'accesso ai valori contenuti in esso: per evitare che più utenti modifichino contemporaneamente un valore della collezione, dando risultati non previsti, si utilizzano le istruzioni Lock e Unlock. Con l'oggetto Cache questo lavoro viene compiuto dalla classe stessa in maniera trasparente;
• scadenza della Cache basata sulla dipendenza. La classe ti permette di stabilire una scadenza della coppia chiave/valore che può essere legata alla scadenza di un'altra chiave, al verificarsi di eventuali modifiche apportate ad un file o ad una specifica data;
• Funzione di callback: quando scade una chiave la classe Cache è in grado di richiamare tramite delegate una nostra funzione in grado di riassegnare un nuovo valore.

Un delegate non è altro che un puntatore ad funzione o ad una sub.

Per utilizzare un delegate, in VB.NET, si fa uso dell'istruzione AddressOf nomefunzione.

Viene restituita una classe che eredita da System.Delegate e che restituisce un puntatore alla funzione specificata.

Ogni qualvolta noi richiamiamo quella classe, la funzione a cui punta verrà eseguita.

Vi accorgerete che in realtà voi i delegate gli avete giù usati. Gli eventi infatti non sono altro che delegate che puntano a funzioni da eseguire ogniqualvolta un determinato evento viene scatenato.

Sicuramente questo concetto è più trasparente per chi programma in C#, dove si fa uso degli EventHandler.

In pratica

E' possibile assegnare una normale coppia chiave/valore con la stessa sintassi utilizzata per l'oggetto Application:

Cache("miaChiave") = "mioValore"

oppure tramite il metodo Insert che ha a disposizione alcuni overloads per i nostri scopi. Il più semplice è:

Cache.Insert("miaChiave","mioValore")

Chiave accetta il tipo string e valore qualsiasi tipo derivante da object, di conseguenza qualsiasi oggetto di .NET.

Per leggere in valore si utilizzerà invece:

valore = Cache("miaChiave")

oppure

valore = Cache.Get("miaChiave")

Per rimuovere la chiave si userà il metodo Remove (ritorna il valore cancellato):

Cache.Remove("miaChiave")

Funzionalità avanzate

Vediamo ora le funzioni più avanzate. Un overload del metodo Insert accetta come argomento un oggetto CacheDependency, che ci permette di legare la validità dell'oggetto inserito ad un determinato evento.

Il costruttore di ques'ultimo accetta:

• il percorso interno di uno o più files o directories.
• l'ora in cui il framework inizia a controllare se la risorsa è stata modificata o meno;
• il nome di un'altra chiave a cui associare la scadenza della chiave stessa;
• un ulteriore oggetto CacheDependency alla quale legare un'altra dipendenza.

Un esempio che mostra come legare la scadenza di una chiave ad un file che contiene le nostre configurazioni:

'codice che legge dal file myconfig.xml e preleva la stringa di connessione (connectionString)

Cache.Insert("DSN",connectonString, New CacheDependency(Sever.MapPath("myconfig.xml")))

La classe CacheDependency è in grado si monitorare un file e una directory e di accorgersi se questi sono stati modificati. Quando questo avverrà la chiave scadrà e non avrà nessun valore (nel nostro caso la chiave DSN) scatenando di conseguenza l'eventuale callback per la gestione della scadenza della nostra chiave.

Un altro overload della classe Insert accetta due ulteriori paramentri:

• un oggetto DateTime che indica la data e l'ora precisa in cui la chiave scade ( absoluteExpiration) ;
• un oggetto TimeSpan che indica l'intervallo ti tempo che deve trascorrere dall'ultimo accesso alla chiave prima di dichiarare la chiave scaduta( slidingExpiration) .

Prendiamo l'esempio di prima e modifichiamolo facendo scadere la chiave dopo due minuti dall'assegnazione:

Cache.Insert("DSN",connectonString, Nothing, DateTime.Now.AddMinutes(2), TimeSpan.Zero)

Se vogliamo usufruire di una scadenza precisa e non di una scadenza dopo un certo intervallo dall'ultimo accesso basta specificare il campo absoluteExpiration normalmente e passare come slidingExpiration la costante TimeSpan.Zero (come nell'esempio). Viceversa assegniamo come absoluteExpiration DateTime.MaxValue e come slidingExpiration il nostro intervallo di tempo.

altri overload accettano questi parametri:

• un tipo enumerativo CacheItemProperty che indica la priorità della chiave. Questa priorità serve alla classe Cache per sapere quali chiave deve rimuovere per primo o per ultimo, per ottimizzare l'occupazione di memoria;
• un delegate del tipo CacheItemRemovedCallBack che punta ad una funzione che verrà chiamata ogni qual volta la chiave scade. La funzione deve avere una firma precisa, cioè avere i seguenti parametri: la chiave che viene rimossa di tipo string, il valore che conteneva (string) e la ragione per cui è stato rimosso (del tipo CacheItemRemovedReason).