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

di Scott Mitchell

Scarica il PDF

Nell'esercitazione precedente si è appreso come applicare la memorizzazione nella cache al livello presentazione. In questa esercitazione viene illustrato come sfruttare l'architettura a 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 impostare un paio di proprietà. Purtroppo, ObjectDataSource applica la memorizzazione nella cache al livello presentazione, che associa strettamente i criteri di memorizzazione nella cache alla pagina ASP.NET. Uno dei motivi per la creazione di un'architettura a livelli consiste nel consentire l'interruzione di tali accoppiamenti. Il livello di logica di business, ad esempio, separa la logica di business dalle pagine ASP.NET, mentre il livello di accesso ai dati disaccoppia i dettagli dell'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, più gestibile e più flessibile da modificare. Consente anche la conoscenza e la divisione del lavoro di uno sviluppatore che lavora sul livello presentazione non deve avere familiarità con i dettagli del database per eseguire il proprio lavoro. La separazione dei criteri di memorizzazione nella cache dal livello presentazione offre vantaggi simili.

In questa esercitazione verrà aumentata l'architettura per includere un livello di memorizzazione nella cache (o CL per breve) che usa i criteri di memorizzazione nella cache. 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à prima di tutto di recuperare i dati dalla cache. Se la cache è vuota, questi metodi richiameranno il metodo appropriato ProductsBLL nel BLL, che a sua volta otterrebbe i dati dal DAL. I ProductsCL metodi memorizzano nella cache i dati recuperati dal BLL prima di restituirlo.

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

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

Passaggio 1: Creazione delle classi livello di memorizzazione nella cache

In questa esercitazione verrà creato un CL molto semplice con una singola classe ProductsCL con solo pochi metodi. La creazione di un livello di memorizzazione nella cache completa per l'intera applicazione richiederebbe la creazione CategoriesCLdi classi , EmployeesCLe SuppliersCL e fornire un metodo in queste classi livello di memorizzazione nella cache per ogni metodo di accesso o modifica dei dati nel BLL. Come per BLL e DAL, il livello di memorizzazione nella cache deve essere implementato idealmente come progetto di libreria di classi separato; verrà tuttavia implementata come classe nella App_Code cartella.

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 nella Esplora soluzioni scegliere Nuova cartella e assegnare un nome alla nuova cartellaCL. Dopo aver creato questa cartella, aggiungerla a 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 e modifica dei dati trovati nella classe Business Logic Layer corrispondente (ProductsBLL). Invece di creare tutti questi metodi, è sufficiente creare un paio qui per ottenere un'idea dei modelli usati da CL. In particolare, verranno aggiunti i GetProducts() metodi e GetProductsByCategoryID(categoryID) nel passaggio 3 e un UpdateProduct overload nel passaggio 4. È possibile aggiungere i metodi rimanenti ProductsCL e , e SuppliersCLCategoriesCLEmployeesCLle classi in tempo libero.

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 alla cache dei dati a livello di codice dalle classi code-behind delle pagine ASP.NET o dalle classi nell'architettura dell'applicazione Web. Per leggere e scrivere nella cache dei dati da una classe code-behind di una pagina ASP.NET, usare il modello seguente:

// 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 Cache metodo della Insert classe ha un numero di overload. Cache["key"] = value e sono sinonimo e Cache.Insert(key, value) 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 su tempo o entrambi. Usare uno degli overload di un altro Insert metodo per fornire informazioni sulla scadenza basata su dipendenze o tempo.

I metodi del livello di memorizzazione nella cache devono prima verificare 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 della sequenza seguente.

Figura 3: I metodi del livello di memorizzazione nella cache restituiscono i dati dalla cache se è disponibile

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, ad esempio mentre la chiave è la chiave che identifica in modo univoco l'elemento della cacheNorthwind.ProductsDataTable. Se l'elemento con la chiave specificata non si trova nella cache, l'istanzanull sarà e i dati verranno recuperati dal metodo BLL appropriato e aggiunti alla cache. Dopo aver raggiunto l'ora return instance , l'istanza contiene un riferimento ai dati, dalla cache o estratta dalla BLL.

Assicurarsi di usare il modello precedente durante l'accesso ai dati dalla cache. Il modello seguente, che, a prima vista, sembra equivalente, contiene una sottile differenza che introduce una condizione di razza. Le condizioni di gara sono difficili da eseguire perché si rivelano 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 errato è che anziché archiviare un riferimento all'elemento memorizzato nella cache in una variabile locale, la cache dei dati viene accessibile direttamente nell'istruzione condizionale e in return. Si supponga che quando viene raggiunto questo codice, non ènull possibile, ma prima che venga raggiunta l'istruzione, Cache["key"] il return sistema espelle la chiave dalla cache. In questo caso raro, il codice restituirà un valore anziché un null oggetto del tipo previsto.

Nota

La cache dei dati è thread-safe, quindi non è necessario sincronizzare l'accesso al thread per semplici letture o scritture. Tuttavia, se è necessario eseguire più operazioni sui dati nella cache che devono essere atomiche, è responsabile dell'implementazione di un blocco o di un altro meccanismo per garantire la sicurezza dei thread. 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 simile al seguente:

Cache.Remove(key);

Passaggio 3: Restituzione di informazioni sul prodotto dallaProductsCLclasse

Per questa esercitazione è possibile implementare due metodi per restituire informazioni sul prodotto dalla ProductsCL classe: GetProducts() e GetProductsByCategoryID(categoryID). Come per la ProductsBL classe nel livello di 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 mostra 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 un oggetto ObjectDataSource nel livello presentazione, sono stati aggiunti questi attributi per migliorare l'esperienza 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 brevemente, restituisce un particolare elemento dalla cache in base alla chiave specificata. Se non vengono trovati dati di questo tipo nella cache, viene recuperato dal metodo di classe corrispondente ProductsBLL e quindi aggiunto 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 usa il valore della chiave fornito, ma chiama invece il GetCacheKey(key) metodo, che restituisce la chiave prependata con ProductsCache-. Il MasterCacheKeyArray, che contiene la stringa ProductsCache, viene usato anche dal AddCacheItem(key, value) metodo, come si vedrà momentaneamente.

Da una classe code-behind della pagina ASP.NET, è possibile accedere alla cache dei dati usando la proprietà della Cacheclasse e consente la Page sintassi come Cache["key"] = value, come illustrato nel passaggio 2. Da una classe all'interno dell'architettura, è possibile accedere alla cache dei dati usando HttpRuntime.Cache o HttpContext.Current.Cache. La voce di blog di Peter JohnsonHttpRuntime.Cache vs. HttpContext.Current.Cache nota il vantaggio di prestazioni leggero nell'uso HttpRuntime anziché HttpContext.Currentin ; di conseguenza, ProductsCL usa HttpRuntime.

Nota

Se l'architettura viene implementata usando i 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 di metodo disponga di parametri di input per una scadenza assoluta e scorrevole, è possibile specificare solo uno dei due. Se si tenta di specificare sia un intervallo di tempo assoluto che un intervallo di tempo, il Insert metodo genererà un'eccezione ArgumentException .

Nota

Questa implementazione del AddCacheItem(key, value) metodo attualmente presenta alcune carenze. Verranno risolti e superati questi problemi 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 cl non modificano i dati memorizzati nella cache, ma chiamano invece il metodo di modifica dei dati corrispondente di BLL e quindi invalidano la cache. Come illustrato nell'esercitazione precedente, si tratta dello stesso comportamento applicato da ObjectDataSource quando vengono abilitate le funzionalità di memorizzazione nella cache e Inserti relativi metodi , Updateo Delete vengono richiamati.

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;
}

Il metodo Business Logic Layer di modifica dei dati appropriato viene richiamato, ma prima che venga restituita la risposta, è necessario invalidare la cache. Sfortunatamente, l'invalidazione della cache non è semplice perché la ProductsCL classe e GetProducts()GetProductsByCategoryID(categoryID) i metodi ognuno aggiunge elementi alla cache con chiavi diverse e il GetProductsByCategoryID(categoryID) metodo aggiunge un elemento cache diverso per ogni categoryID univoco.

Quando si invalida la cache, è necessario rimuovere tutti gli elementi che potrebbero essere stati aggiunti dalla ProductsCL classe. Questa operazione può essere eseguita associando 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 dati da un database di Microsoft SQL Server. Quando la dipendenza cambia o viene rimossa dalla cache, gli elementi della cache associati 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 rimuovendo semplicemente la dipendenza della cache.

Consente di 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 un numero di overload, ma quello usato in questo caso prevede due string input della matrice. Il primo specifica il set di file da usare come dipendenze. Poiché non si vogliono usare dipendenze basate su file, viene usato un valore di per il primo parametro di null 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. Viene CacheDependency quindi passato al Insert metodo .

Con questa modifica a AddCacheItem(key, value), l'invalidazione della cache è semplice come rimuovere la 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: Chiamata del livello di memorizzazione nella cache dal livello di presentazione

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

Figura 4: La ProductsCL classe è inclusa nell'elenco di Drop-Down oggetti business (fare clic per visualizzare l'immagine full-size)

Dopo aver ProductsCLselezionato , fare clic su Avanti. L'elenco a discesa nella scheda SELECT include due elementi GetProducts() e GetProductsByCategoryID(categoryID) la scheda UPDATE ha l'overload unico 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 nella Drop-Down Elenchi (fare clic per visualizzare l'immagine a dimensioni complete)

Al termine della procedura guidata, Visual Studio imposta la proprietà original_{0} ObjectDataSource su OldValuesParameterFormatString e aggiungerà i campi appropriati a GridView. Modificare la proprietà nel valore predefinito, e configurare GridView per supportare il paging, {0}l'ordinamento OldValuesParameterFormatString 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 oggetto GridView per includere campi per i ProductNamecampi , CategoryNamee UnitPrice . È possibile replicare questa formattazione e struttura, nel qual caso il markup dichiarativo 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 è disponibile una pagina che usa il livello di memorizzazione nella cache. Per visualizzare la cache in azione, impostare i punti di interruzione nella ProductsCL classe s GetProducts() e UpdateProduct nei metodi. Visitare la pagina in un browser e seguire il codice durante l'ordinamento e il paging per visualizzare i dati estratti dalla cache. Aggiornare quindi un record e notare che la cache non è valida e, di conseguenza, viene recuperata dal BLL quando i dati vengono rebound in GridView.

Nota

Il livello di memorizzazione nella cache fornito nel download che accompagna questo articolo non è completo. Contiene solo una classe, , ProductsCLche sport solo una manciata di metodi. Inoltre, solo una singola pagina ASP.NET usa il CL (~/Caching/FromTheArchitecture.aspx) tutti gli altri ancora fanno riferimento direttamente al BLL. Se si prevede di usare un CL nell'applicazione, tutte le chiamate dal livello di presentazione devono passare a CL, che richiederebbe che le classi e i metodi CL trattassero tali classi e metodi nel BLL attualmente usato dal livello di presentazione.

Riepilogo

Anche se la memorizzazione nella cache può essere applicata al livello di presentazione con i controlli SqlDataSource e ObjectDataSource ASP.NET 2.0, le responsabilità di memorizzazione nella cache idealmente verranno delegate a un livello separato nell'architettura. In questa esercitazione è stato creato un livello di memorizzazione nella cache che si trova tra il livello presentazione e il livello di logica di business. Il livello di memorizzazione nella cache deve fornire lo stesso set di classi e metodi esistenti nel BLL e viene chiamato dal livello presentazione.

Gli esempi di livello di memorizzazione nella cache sono stati esaminati in questo e le esercitazioni precedenti hanno mostrato il 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.

Programmazione felice!

Informazioni sull'autore

Scott Mitchell, autore di sette libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, ha lavorato con le tecnologie Microsoft Web dal 1998. Scott lavora come consulente indipendente, allenatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2,0 in 24 Ore. Può essere raggiunto a mitchell@4GuysFromRolla.com. o tramite il suo blog, che può essere trovato in http://ScottOnWriting.NET.

Grazie speciali

Questa serie di esercitazioni è stata esaminata da molti revisori utili. Il revisore principale per questa esercitazione era Teresa Murph. Interessati a esaminare i prossimi articoli MSDN? In tal caso, lasciami una riga in mitchell@4GuysFromRolla.com.

IndietroAvanti