Memorizzazione di dati nella cache nell'architettura (C#)

di Scott Mitchell

Scaricare il PDF

Nell'esercitazione precedente si è appreso come applicare la memorizzazione nella cache a livello di presentazione. Questa esercitazione illustra come sfruttare l'architettura a più livelli per memorizzare nella cache i dati a livello di logica di business. Questa operazione viene eseguita estendendo l'architettura per includere un livello di memorizzazione nella cache.

Introduzione

Come illustrato nell'esercitazione precedente, la memorizzazione nella cache dei dati di ObjectDataSource è semplice come l'impostazione di un paio di proprietà. Sfortunatamente, ObjectDataSource applica la memorizzazione nella cache a livello di presentazione, che associa strettamente i criteri di memorizzazione nella cache alla pagina ASP.NET. Uno dei motivi per cui si crea un'architettura a più livelli è consentire l'interruzione di tali accoppiamenti. Il livello di logica di business, ad esempio, separa la logica di business dalle pagine di ASP.NET, mentre il livello di accesso ai dati separa i dettagli di accesso ai dati. Questo disaccoppiamento della logica di business e dei dettagli di accesso ai dati è preferibile, in parte, perché rende il sistema più leggibile, gestibile e più flessibile da modificare. Consente anche la conoscenza del dominio e la divisione del lavoro che uno sviluppatore che lavora sul livello presentazione non deve avere familiarità con i dettagli del database per svolgere il suo lavoro. La separazione dei criteri di memorizzazione nella cache dal livello presentazione offre vantaggi simili.

In questa esercitazione amplieremo la nostra architettura per includere un livello di memorizzazione nella cache (o CL per brevità) che usa la nostra politica di caching. Il livello di memorizzazione nella cache includerà una ProductsCL classe che fornisce l'accesso alle informazioni sul prodotto con metodi come GetProducts(), GetProductsByCategoryID(categoryID)e così via, che, quando richiamato, tenterà innanzitutto di recuperare i dati dalla cache. Se la cache è vuota, questi metodi richiameranno il metodo appropriato ProductsBLL nel BLL, che a sua volta otterrà i dati dal DAL. I ProductsCL metodi memorizzano nella cache i dati recuperati dal BLL prima di restituirli.

Come illustrato nella figura 1, cl risiede tra i livelli presentazione e logica di business.

Figura 1: Il livello di memorizzazione nella cache (CL) è un altro livello nell'architettura

Passaggio 1: Creazione delle classi del livello di memorizzazione nella cache

In questa esercitazione si creerà una cl molto semplice con una singola classe ProductsCL che include solo pochi metodi. La creazione di un livello di memorizzazione nella cache completo per l'intera applicazione richiederebbe la creazione delle classi CategoriesCL, EmployeesCL e SuppliersCL, e la definizione di un metodo in queste classi del livello di memorizzazione nella cache per ciascun metodo di accesso o modifica dei dati nel BLL. Come per BLL e DAL, il livello cache dovrebbe essere implementato idealmente come progetto di libreria di classi separato; tuttavia, lo implementeremo come classe nella cartella App_Code.

Per separare in modo più pulito le classi CL dalle classi DAL e BLL, creare una nuova sottocartella nella App_Code cartella . Fare clic con il pulsante destro del mouse sulla App_Code cartella in Esplora soluzioni, scegliere Nuova cartella e assegnare alla nuova cartella CLil nome . Dopo aver creato questa cartella, aggiungerla a essa una nuova classe denominata ProductsCL.cs.

Figura 2: Aggiungere una nuova cartella denominata CL e una classe denominata ProductsCL.cs

La ProductsCL classe deve includere lo stesso set di metodi di accesso ai dati e di modifica disponibili nella corrispondente classe livello di logica di business (ProductsBLL). Invece di creare tutti questi metodi, è sufficiente creare un paio qui per ottenere un'idea dei modelli usati da CL. In particolare, aggiungeremo i metodi GetProducts() e il GetProductsByCategoryID(categoryID) nel passaggio 3 e un sovraccarico UpdateProduct nel passaggio 4. È possibile aggiungere i metodi rimanenti ProductsCL e le classi CategoriesCL, EmployeesCL e SuppliersCL a tuo piacimento.

Passaggio 2: Lettura e scrittura nella cache dei dati

La funzionalità di memorizzazione nella cache ObjectDataSource esaminata nell'esercitazione precedente usa internamente la cache dei dati ASP.NET per archiviare i dati recuperati dal BLL. È anche possibile accedere programmaticamente alla cache dei dati dalle pagine code-behind di ASP.NET o dalle classi nell'architettura dell'applicazione web. Per leggere e scrivere nella cache dei dati da una classe code-behind della pagina ASP.NET, usare il seguente schema:

// Read from the cache
object value = Cache["key"];
// Add a new item to the cache
Cache["key"] = value;
Cache.Insert(key, value);
Cache.Insert(key, value, CacheDependency);
Cache.Insert(key, value, CacheDependency, DateTime, TimeSpan);

Il metodo della classe CacheInsert ha una serie di overload. Cache["key"] = value e Cache.Insert(key, value) sono sinonimi ed entrambi aggiungono un elemento alla cache usando la chiave specificata senza una scadenza definita. In genere, si vuole specificare una scadenza quando si aggiunge un elemento alla cache, come dipendenza, una scadenza basata sul tempo o entrambi. Usare uno degli overload degli altri metodi Insert per fornire informazioni sulla scadenza basata su dipendenze o sul tempo.

I metodi del livello di memorizzazione nella cache devono prima controllare se i dati richiesti si trovano nella cache e, in tal caso, restituirli da lì. Se i dati richiesti non si trovano nella cache, è necessario richiamare il metodo BLL appropriato. Il valore restituito deve essere memorizzato nella cache e quindi restituito, come illustrato nel diagramma di sequenza seguente.

Figura 3: I metodi del livello di memorizzazione nella cache restituiscono dati dalla cache, se disponibili

La sequenza illustrata nella figura 3 viene eseguita nelle classi CL usando il modello seguente:

Type instance = Cache["key"] as Type;
if (instance == null)
{
    instance = BllMethodToGetInstance();
    Cache.Insert(key, instance, ...);
}
return instance;

In questo caso , Type è il tipo di dati archiviati nella cache Northwind.ProductsDataTable, ad esempio mentre la chiave è la chiave che identifica in modo univoco l'elemento della cache. Se l'elemento con la chiave specificata non è presente nella cache, l'istanza sarà null e i dati verranno recuperati dal metodo BLL appropriato e aggiunti alla cache. Quando si raggiunge return instance, l'istanza contiene un riferimento ai dati, prelevati dalla cache o dal BLL.

Assicurarsi di usare il modello precedente quando si accede ai dati dalla cache. Il modello seguente, che, a prima vista, sembra equivalente, contiene una sottile differenza che introduce una race condition. Le condizioni di corsa sono difficili da risolvere perché si manifestano sporadicamente e sono difficili da riprodurre.

if (Cache["key"] == null)
{
    Cache.Insert(key, BllMethodToGetInstance(), ...);
}
return Cache["key"];

La differenza in questo secondo frammento di codice non corretto è che anziché archiviare un riferimento all'elemento memorizzato nella cache in una variabile locale, la cache dei dati è accessibile direttamente nell'istruzione condizionale e in return. Si immagini che quando viene raggiunto questo codice, Cache["key"] sia non-null, ma prima che venga raggiunta l'istruzione return, il sistema rimuove dal cache la chiave. In questo caso raro, il codice restituirà un null valore anziché un oggetto del tipo previsto.

Annotazioni

La cache dei dati è thread-safe, quindi non è necessario sincronizzare l'accesso al thread per operazioni di lettura o scrittura semplici. Tuttavia, se è necessario eseguire più operazioni sui dati nella cache che devono essere atomici, è necessario implementare un blocco o un altro meccanismo per garantire la thread safety. Per altre informazioni, vedere Sincronizzazione dell'accesso alla cache ASP.NET .

Un elemento può essere rimosso a livello di codice dalla cache dei dati usando il Remove metodo in questo modo:

Cache.Remove(key);

Passaggio 3: Restituzione di informazioni sul prodotto dallaProductsCLclasse

Per questa esercitazione è possibile implementare due metodi per la restituzione di informazioni sul prodotto dalla ProductsCL classe : GetProducts() e GetProductsByCategoryID(categoryID). Analogamente alla ProductsBL classe nel livello della logica di business, il GetProducts() metodo in CL restituisce informazioni su tutti i prodotti come Northwind.ProductsDataTable oggetto, mentre GetProductsByCategoryID(categoryID) restituisce tutti i prodotti da una categoria specificata.

Il codice seguente illustra una parte dei metodi nella ProductsCL classe :

[System.ComponentModel.DataObject]
public class ProductsCL
{
    private ProductsBLL _productsAPI = null;
    protected ProductsBLL API
    {
        get
        {
            if (_productsAPI == null)
                _productsAPI = new ProductsBLL();
            return _productsAPI;
        }
    }
    
   [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, true)]
    public Northwind.ProductsDataTable GetProducts()
    {
        const string rawKey = "Products";
        // See if the item is in the cache
        Northwind.ProductsDataTable products = _
            GetCacheItem(rawKey) as Northwind.ProductsDataTable;
        if (products == null)
        {
            // Item not found in cache - retrieve it and insert it into the cache
            products = API.GetProducts();
            AddCacheItem(rawKey, products);
        }
        return products;
    }
    
    [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    public Northwind.ProductsDataTable GetProductsByCategoryID(int categoryID)
    {
        if (categoryID < 0)
            return GetProducts();
        else
        {
            string rawKey = string.Concat("ProductsByCategory-", categoryID);
            // See if the item is in the cache
            Northwind.ProductsDataTable products = _
                GetCacheItem(rawKey) as Northwind.ProductsDataTable;
            if (products == null)
            {
                // Item not found in cache - retrieve it and insert it into the cache
                products = API.GetProductsByCategoryID(categoryID);
                AddCacheItem(rawKey, products);
            }
            return products;
        }
    }
}

Prima di tutto, prendere nota degli DataObject attributi e DataObjectMethodAttribute applicati alla classe e ai metodi . Questi attributi forniscono informazioni alla procedura guidata di ObjectDataSource, che indica quali classi e metodi devono essere visualizzati nei passaggi della procedura guidata. Poiché le classi e i metodi CL saranno accessibili da objectDataSource nel livello presentazione, questi attributi sono stati aggiunti per migliorare l'esperienza in fase di progettazione. Per una descrizione più approfondita su questi attributi e sui relativi effetti, vedere l'esercitazione Creazione di un livello di logica di business.

GetProducts() Nei metodi e GetProductsByCategoryID(categoryID) i dati restituiti dal GetCacheItem(key) metodo vengono assegnati a una variabile locale. Il GetCacheItem(key) metodo, che verrà esaminato a breve, restituisce un particolare elemento dalla cache in base alla chiave specificata. Se nella cache non vengono trovati dati di questo tipo, questi vengono recuperati dal metodo della classe corrispondente ProductsBLL e quindi aggiunti alla cache usando il AddCacheItem(key, value) metodo .

I GetCacheItem(key) metodi e AddCacheItem(key, value) si interfacciano rispettivamente con la cache dei dati, la lettura e la scrittura di valori. Il GetCacheItem(key) metodo è più semplice dei due. Restituisce semplicemente il valore dalla classe Cache usando la chiave passata:

private object GetCacheItem(string rawKey)
{
    return HttpRuntime.Cache[GetCacheKey(rawKey)];
}
private readonly string[] MasterCacheKeyArray = {"ProductsCache"};
private string GetCacheKey(string cacheKey)
{
    return string.Concat(MasterCacheKeyArray[0], "-", cacheKey);
}

GetCacheItem(key) non utilizza il valore della chiave come fornito, ma invece chiama il metodo GetCacheKey(key), che restituisce la chiave anteposta con il prefisso ProductsCache-. L'oggetto MasterCacheKeyArray, che contiene la stringa ProductsCache, viene usato anche dal AddCacheItem(key, value) metodo , come si vedrà momentaneamente.

Da una classe code-behind di una pagina ASP.NET, è possibile accedere alla cache dei dati usando la proprietà Page della classe Cache, e permette l'uso di una sintassi come , come illustrato nella Fase 2. Da una classe all'interno dell'architettura, è possibile accedere alla cache dei dati usando HttpRuntime.Cache o HttpContext.Current.Cache. Il post di blog di Peter JohnsonHttpRuntime.Cache vs. HttpContext.Current.Cache rileva il lieve vantaggio delle prestazioni nell'uso HttpRuntime anziché HttpContext.Currentin . Di conseguenza, ProductsCL usa HttpRuntime.

Annotazioni

Se l'architettura viene implementata usando progetti libreria di classi, sarà necessario aggiungere un riferimento all'assembly System.Web per usare le classi HttpRuntime e HttpContext .

Se l'elemento non viene trovato nella cache, i ProductsCL metodi della classe ottengono i dati dal BLL e lo aggiungono alla cache usando il AddCacheItem(key, value) metodo . Per aggiungere valore alla cache, è possibile usare il codice seguente, che usa una scadenza di 60 secondi:

const double CacheDuration = 60.0;
private void AddCacheItem(string rawKey, object value)
{
    HttpRuntime.Cache.Insert(GetCacheKey(rawKey), value, null, 
        DateTime.Now.AddSeconds(CacheDuration), Caching.Cache.NoSlidingExpiration);
}

DateTime.Now.AddSeconds(CacheDuration) specifica la scadenza in base al tempo 60 secondi in futuro, mentre System.Web.Caching.Cache.NoSlidingExpiration indica che non esiste una scadenza scorrevole. Sebbene questo Insert overload del metodo includa parametri di input per una scadenza assoluta e scorrevole, è possibile specificarne solo uno dei due. Se si tenta di specificare sia un tempo assoluto che un intervallo di tempo, il Insert metodo genererà un'eccezione ArgumentException .

Annotazioni

Questa implementazione del AddCacheItem(key, value) metodo presenta attualmente alcune carenze. Questi problemi verranno affrontati e risolti nel passaggio 4.

Passaggio 4: Invalidazione della cache quando i dati vengono modificati tramite l'architettura

Oltre ai metodi di recupero dei dati, il livello di memorizzazione nella cache deve fornire gli stessi metodi del BLL per l'inserimento, l'aggiornamento e l'eliminazione dei dati. I metodi di modifica dei dati cls non modificano i dati memorizzati nella cache, ma chiamano invece il metodo di modifica dei dati BLL corrispondente e quindi invalidano la cache. Come illustrato nell'esercitazione precedente, questo è lo stesso comportamento applicato da ObjectDataSource quando le sue funzionalità di memorizzazione nella cache sono abilitate e vengono richiamati i metodi Insert, Update o Delete.

L'overload seguente UpdateProduct illustra come implementare i metodi di modifica dei dati in CL:

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // TODO: Invalidate the cache
    return result;
}

Viene richiamato il metodo di business logic layer di modifica dei dati appropriato, ma prima che venga restituita la risposta, è necessario invalidare la cache. Sfortunatamente, l'invalidazione della cache non è semplice perché la ProductsCL classe s GetProducts() e GetProductsByCategoryID(categoryID) i metodi aggiungono elementi alla cache con chiavi diverse e il GetProductsByCategoryID(categoryID) metodo aggiunge un elemento della cache diverso per ogni id categoria univoco.

Quando si invalida la cache, è necessario rimuovere tutti gli elementi che potrebbero essere stati aggiunti dalla ProductsCL classe . A tale scopo, è possibile associare una dipendenza della cache a ogni elemento aggiunto alla cache nel AddCacheItem(key, value) metodo . In generale, una dipendenza della cache può essere un altro elemento nella cache, un file nel file system o i dati di un database di Microsoft SQL Server. Quando la dipendenza cambia o viene rimossa dalla cache, gli elementi della cache a cui è associato vengono rimossi automaticamente dalla cache. Per questa esercitazione si vuole creare un elemento aggiuntivo nella cache che funge da dipendenza della cache per tutti gli elementi aggiunti tramite la ProductsCL classe . In questo modo, tutti questi elementi possono essere rimossi dalla cache semplicemente rimuovendo la dipendenza della cache.

Aggiornare il AddCacheItem(key, value) metodo in modo che ogni elemento aggiunto alla cache tramite questo metodo sia associato a una singola dipendenza della cache:

private void AddCacheItem(string rawKey, object value)
{
    System.Web.Caching.Cache DataCache = HttpRuntime.Cache;
    // Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
    if (DataCache[MasterCacheKeyArray[0]] == null)
        DataCache[MasterCacheKeyArray[0]] = DateTime.Now;
    // Add a CacheDependency
    System.Web.Caching.CacheDependency dependency = 
        new CacheDependency(null, MasterCacheKeyArray);
    DataCache.Insert(GetCacheKey(rawKey), value, dependency, 
        DateTime.Now.AddSeconds(CacheDuration), 
        System.Web.Caching.Cache.NoSlidingExpiration);
}

MasterCacheKeyArray è una matrice di stringhe che contiene un singolo valore, ProductsCache. Prima di tutto, un elemento della cache viene aggiunto alla cache e assegnato la data e l'ora correnti. Se l'elemento della cache esiste già, viene aggiornato. Viene quindi creata una dipendenza della cache. Il CacheDependency costruttore della classe ha diversi overload, ma quello in uso qui prevede due string input di array. Il primo specifica il set di file da usare come dipendenze. Poiché non si vogliono usare dipendenze basate su file, viene utilizzato un valore di null per il primo parametro di input. Il secondo parametro di input specifica il set di chiavi della cache da usare come dipendenze. In questo caso viene specificata la singola dipendenza, MasterCacheKeyArray. L'oggetto CacheDependency viene quindi passato al Insert metodo .

Con questa modifica a AddCacheItem(key, value), l'invalidazione della cache è semplice come la rimozione della dipendenza.

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // Invalidate the cache
    InvalidateCache();
    return result;
}
public void InvalidateCache()
{
    // Remove the cache dependency
    HttpRuntime.Cache.Remove(MasterCacheKeyArray[0]);
}

Passaggio 5: Chiamare il livello di memorizzazione nella cache dal livello di presentazione

Le classi e i metodi del livello di memorizzazione nella cache possono essere usati per lavorare con i dati usando le tecniche esaminate in queste esercitazioni. Per illustrare l'uso dei dati memorizzati nella cache, salvare le modifiche apportate alla ProductsCL classe e quindi aprire la FromTheArchitecture.aspx pagina nella Caching cartella e aggiungere un controllo GridView. Dalla smart tag di GridView, creare un nuovo ObjectDataSource. Nel primo passaggio della procedura guidata dovrebbe essere visualizzata la ProductsCL classe come una delle opzioni nell'elenco a discesa.

Figura 4: La ProductsCL classe è inclusa nell'elenco Drop-Down oggetto business (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver selezionato ProductsCL, fare clic su Avanti. L'elenco a discesa nella scheda SELECT include due elementi: GetProducts() e GetProductsByCategoryID(categoryID), mentre la scheda UPDATE ha l'unico overload UpdateProduct. Scegliere il GetProducts() metodo dalla scheda SELECT e il UpdateProducts metodo dalla scheda UPDATE e fare clic su Fine.

Figura 5: I ProductsCL metodi della classe sono elencati negli elenchi di Drop-Down (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver completato la procedura guidata, Visual Studio imposta la proprietà OldValuesParameterFormatString ObjectDataSource su original_{0} e aggiunge i campi appropriati a GridView. Ripristinare il valore predefinito della OldValuesParameterFormatString proprietà e {0}configurare GridView per supportare il paging, l'ordinamento e la modifica. Poiché l'overload UploadProducts usato da CL accetta solo il nome e il prezzo del prodotto modificati, limitare GridView in modo che solo questi campi siano modificabili.

Nell'esercitazione precedente è stato definito un controllo GridView per includere i campi ProductName, CategoryName, e UnitPrice. È possibile replicare questa formattazione e struttura, nel qual caso il markup dichiarativo di GridView e ObjectDataSource dovrebbe essere simile al seguente:

<asp:GridView ID="Products" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="ProductID" DataSourceID="ProductsDataSource" 
    AllowPaging="True" AllowSorting="True">
    <Columns>
        <asp:CommandField ShowEditButton="True" />
        <asp:TemplateField HeaderText="Product" SortExpression="ProductName">
            <EditItemTemplate>
                <asp:TextBox ID="ProductName" runat="server" 
                    Text='<%# Bind("ProductName") %>' />
                <asp:RequiredFieldValidator ID="RequiredFieldValidator1"
                    ControlToValidate="ProductName" Display="Dynamic" 
                    ErrorMessage="You must provide a name for the product." 
                    SetFocusOnError="True"
                    runat="server">*</asp:RequiredFieldValidator>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label2" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            ReadOnly="True" SortExpression="CategoryName" />
        <asp:TemplateField HeaderText="Price" SortExpression="UnitPrice">
            <EditItemTemplate>
                $<asp:TextBox ID="UnitPrice" runat="server" Columns="8" 
                    Text='<%# Bind("UnitPrice", "{0:N2}") %>'></asp:TextBox>
                <asp:CompareValidator ID="CompareValidator1" runat="server" 
                    ControlToValidate="UnitPrice" Display="Dynamic" 
                    ErrorMessage="You must enter a valid currency value with 
                        no currency symbols. Also, the value must be greater than 
                        or equal to zero."
                    Operator="GreaterThanEqual" SetFocusOnError="True" 
                    Type="Currency" ValueToCompare="0">*</asp:CompareValidator>
            </EditItemTemplate>
            <ItemStyle HorizontalAlign="Right" />
            <ItemTemplate>
                <asp:Label ID="Label1" runat="server" 
                    Text='<%# Bind("UnitPrice", "{0:c}") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server" 
    OldValuesParameterFormatString="{0}" SelectMethod="GetProducts" 
    TypeName="ProductsCL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

A questo punto abbiamo una pagina che usa lo strato di cache. Per visualizzare la cache in azione, impostare i punti di interruzione nella classe ProductsCL s GetProducts() e UpdateProduct i metodi. Visita la pagina in un browser e passa attraverso il codice durante le operazioni di ordinamento e paginazione per vedere i dati estratti dalla cache. Quindi, aggiorna un record e nota che la cache viene invalidata e, di conseguenza, i dati vengono recuperati dal BLL quando vengono vincolati nuovamente al GridView.

Annotazioni

Il livello di memorizzazione nella cache fornito nel download a cui si accompagna questo articolo non è completo. Contiene solo una classe, ProductsCL, che dispone solo di una manciata di metodi. Inoltre, solo una singola pagina ASP.NET usa cl (~/Caching/FromTheArchitecture.aspx) tutte le altre ancora fanno riferimento direttamente al BLL. Se si prevede di usare un CL nell'applicazione, tutte le chiamate dal livello di presentazione dovrebbero passare al CL, il che richiederebbe che le classi e i metodi del CL coprissero quelle classi e metodi nel BLL attualmente usati dal livello di presentazione.

Riassunto

Anche se la memorizzazione nella cache può essere applicata a livello di presentazione con i controlli SqlDataSource e ObjectDataSource di ASP.NET 2.0, idealmente le responsabilità di memorizzazione nella cache verrebbero delegate a un livello separato nell'architettura. In questo tutorial, abbiamo creato un livello di cache che si trova tra il livello di presentazione e il livello della logica aziendale. Il livello di memorizzazione nella cache deve fornire lo stesso set di classi e metodi esistenti nel BLL che vengono chiamati dal livello di presentazione.

Gli esempi del livello di memorizzazione nella cache illustrati in questo e nelle esercitazioni precedenti hanno mostrato caricamento reattivo. Con il caricamento reattivo, i dati vengono caricati nella cache solo quando viene effettuata una richiesta per i dati e che i dati non sono presenti nella cache. I dati possono anche essere caricati in modo proattivo nella cache, una tecnica che carica i dati nella cache prima che sia effettivamente necessaria. Nell'esercitazione successiva verrà illustrato un esempio di caricamento proattivo quando si esamina come archiviare i valori statici nella cache all'avvio dell'applicazione.

Buon programmatori!

Informazioni sull'autore

Scott Mitchell, autore di sette libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, ha lavorato con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, formatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2.0 in 24 ore. Può essere raggiunto a mitchell@4GuysFromRolla.com.

Grazie speciale a

Questa serie di esercitazioni è stata esaminata da molti revisori competenti. Il revisore principale per questo tutorial era Teresa Murph. Si è interessati a esaminare i prossimi articoli MSDN? In tal caso, mandami un messaggio a mitchell@4GuysFromRolla.com.

PrecedenteAvanti