Memorizzazione di dati nella cache nell'architettura (VB)
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à. Purtroppo, 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 la creazione di un'architettura a più livelli è consentire l'interruzione di tali accoppiamenti. Il livello della 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 di 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 verrà aumentata l'architettura per includere un livello di memorizzazione nella cache (o CL per brevità) 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 da 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 presentazione e logica di 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 che include solo una manciata di metodi. La creazione di un livello di memorizzazione nella cache completo per l'intera applicazione richiederebbe la creazione CategoriesCLdi classi , EmployeesCLe SuppliersCL e fornendo 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; Tuttavia, verrà implementata come classe nella App_Code cartella .
Per separare in modo più pulito le classi CL dalle classi DAL e BLL, è possibile creare una nuova sottocartella nella App_Code cartella . Fare clic con il App_Code pulsante destro del mouse sulla cartella nel Esplora soluzioni, scegliere Nuova cartella e assegnare alla nuova cartella CLil nome . Dopo aver creato questa cartella, aggiungerla a una nuova classe denominata ProductsCL.vb.
Figura 2: Aggiungere una nuova cartella denominata CL e una classe denominata ProductsCL.vb
La ProductsCL classe deve includere lo stesso set di metodi di accesso ai dati e di modifica disponibili nella corrispondente classe Livello 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, 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 CategoriesCLle classi , EmployeesCLe SuppliersCL nel 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 da ASP.NET pagine di classi code-behind 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 modello seguente:
' Read from the cache
Dim value as Object = 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 classe ha Insert un numero 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, scadenza basata sul tempo o entrambe. Usare uno degli overload dell'altro Insert metodo per fornire informazioni sulla scadenza basate 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, restituirlo da questa posizione. 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:
Dim instance As Type = TryCast(Cache("key"), Type)
If instance Is Nothing Then
instance = BllMethodToGetInstance()
Cache.Insert(key, instance, ...)
End If
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 si trova nella cache, l'istanza sarà Nothing e i dati verranno recuperati dal metodo BLL appropriato e aggiunti alla cache. Quando viene raggiunto il tempo Return instance , l'istanza contiene un riferimento ai dati, 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 race condition sono difficili da eseguire perché si rivelano sporadicamente e sono difficili da riprodurre.
If Cache("key") Is Nothing Then
Cache.Insert(key, BllMethodToGetInstance(), ...)
End If
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, l'accesso alla cache dei dati viene eseguito direttamente nell'istruzione condizionale e in Return. Si supponga che quando viene raggiunto Cache("key") questo codice non Nothingsia , ma prima che venga raggiunta l'istruzione Return , la chiave di sistema rimuove dalla cache. In questo raro caso, il codice restituirà Nothing anziché un oggetto del tipo previsto.
Nota
La cache dei dati è thread-safe, quindi non è necessario sincronizzare l'accesso ai thread per operazioni di lettura o scrittura semplici. Tuttavia, se è necessario eseguire più operazioni sui dati nella cache che devono essere atomici, si è responsabili dell'implementazione di un blocco o di 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 mostra una parte dei metodi nella ProductsCL classe :
<System.ComponentModel.DataObject()> _
Public Class ProductsCL
Private _productsAPI As ProductsBLL = Nothing
Protected ReadOnly Property API() As ProductsBLL
Get
If _productsAPI Is Nothing Then
_productsAPI = New ProductsBLL()
End If
Return _productsAPI
End Get
End Property
<System.ComponentModel.DataObjectMethodAttribute _
(DataObjectMethodType.Select, True)> _
Public Function GetProducts() As Northwind.ProductsDataTable
Const rawKey As String = "Products"
' See if the item is in the cache
Dim products As Northwind.ProductsDataTable = _
TryCast(GetCacheItem(rawKey), Northwind.ProductsDataTable)
If products Is Nothing Then
' Item not found in cache - retrieve it and insert it into the cache
products = API.GetProducts()
AddCacheItem(rawKey, products)
End If
Return products
End Function
<System.ComponentModel.DataObjectMethodAttribute _
(DataObjectMethodType.Select, False)> _
Public Function GetProductsByCategoryID(ByVal categoryID As Integer) _
As Northwind.ProductsDataTable
If (categoryID < 0) Then
Return GetProducts()
Else
Dim rawKey As String = String.Concat("ProductsByCategory-", categoryID)
' See if the item is in the cache
Dim products As Northwind.ProductsDataTable = _
TryCast(GetCacheItem(rawKey), Northwind.ProductsDataTable)
If products Is Nothing Then
' Item not found in cache - retrieve it and insert it into the cache
products = API.GetProductsByCategoryID(categoryID)
AddCacheItem(rawKey, products)
End If
Return products
End If
End Function
End Class
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. Fare riferimento all'esercitazione Creazione di un livello di logica di business per una descrizione più approfondita su questi attributi e sui relativi effetti.
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 determinato elemento dalla cache in base alla chiave specificata. Se nella cache non vengono trovati dati di questo tipo, questi vengono recuperati dal metodo di 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 è il più semplice dei due. Restituisce semplicemente il valore della classe Cache usando la chiave passata:
Private Function GetCacheItem(ByVal rawKey As String) As Object
Return HttpRuntime.Cache(GetCacheKey(rawKey))
End Function
Private ReadOnly MasterCacheKeyArray() As String = {"ProductsCache"}
Private Function GetCacheKey(ByVal cacheKey As String) As String
Return String.Concat(MasterCacheKeyArray(0), "-", cacheKey)
End Function
GetCacheItem(key) non usa il valore della chiave come specificato, ma chiama invece il GetCacheKey(key) metodo , che restituisce la chiave anteporta a 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 della pagina ASP.NET, è possibile accedere alla cache dei dati usando la Page proprietà della Cacheclasse e consente la 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. Il post di blog di Peter JohnsonHttpRuntime.Cache vs. HttpContext.Current.Cache nota il lieve vantaggio delle prestazioni nell'uso HttpRuntime invece di HttpContext.Current. 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 HttpRuntime classi 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 CacheDuration As Double = 60.0
Private Sub AddCacheItem(ByVal rawKey As String, ByVal value As Object)
DataCache.Insert(GetCacheKey(rawKey), value, Nothing, _
DateTime.Now.AddSeconds(CacheDuration), _
System.Web.Caching.Cache.NoSlidingExpiration)
End Sub
DateTime.Now.AddSeconds(CacheDuration) specifica la scadenza in base al tempo 60 secondi in futuro, mentre System.Web.Caching.Cache.NoSlidingExpiration indica che non è prevista alcuna scadenza scorrevole. Anche se questo Insert overload del metodo include parametri di input sia per una scadenza assoluta che per quella scorrevole, è possibile specificare 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 .
Nota
Questa implementazione del AddCacheItem(key, value) metodo presenta attualmente alcune carenze. Questi problemi verranno risolti 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 di CL non modificano i dati memorizzati nella cache, ma chiamano invece il metodo di modifica dei dati corrispondente del BLL e quindi invalidano la cache. Come illustrato nell'esercitazione precedente, si tratta dello stesso comportamento applicato da ObjectDataSource quando le funzionalità di memorizzazione nella cache sono abilitate e Insertvengono richiamati i metodi , Updateo Delete .
L'overload seguente UpdateProduct illustra come implementare i metodi di modifica dei dati in CL:
<DataObjectMethodAttribute(DataObjectMethodType.Update, False)> _
Public Function UpdateProduct(productName As String, _
unitPrice As Nullable(Of Decimal), productID As Integer) _
As Boolean
Dim result As Boolean = API.UpdateProduct(productName, unitPrice, productID)
' TODO: Invalidate the cache
Return result
End Function
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 ogni elemento alla cache con chiavi diverse e il GetProductsByCategoryID(categoryID) metodo aggiunge un elemento della cache diverso per ogni categoryID 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.
È possibile 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 Sub AddCacheItem(ByVal rawKey As String, ByVal value As Object)
Dim DataCache As System.Web.Caching.Cache = HttpRuntime.Cache
' Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
If DataCache(MasterCacheKeyArray(0)) Is Nothing Then
DataCache(MasterCacheKeyArray(0)) = DateTime.Now
End If
' Add a CacheDependency
Dim dependency As New Caching.CacheDependency(Nothing, MasterCacheKeyArray) _
DataCache.Insert(GetCacheKey(rawKey), value, dependency, _
DateTime.Now.AddSeconds(CacheDuration), _
System.Web.Caching.Cache.NoSlidingExpiration)
End Sub
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 certo numero di overload, ma quello usato in qui prevede due String input di 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 Nothing 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 quanto la rimozione della dipendenza.
<DataObjectMethodAttribute(DataObjectMethodType.Update, False)> _
Public Function UpdateProduct(ByVal productName As String, _
ByVal unitPrice As Nullable(Of Decimal), ByVal productID As Integer) _
As Boolean
Dim result As Boolean = API.UpdateProduct(productName, unitPrice, productID)
' Invalidate the cache
InvalidateCache()
Return result
End Function
Public Sub InvalidateCache()
' Remove the cache dependency
HttpRuntime.Cache.Remove(MasterCacheKeyArray(0))
End Sub
Passaggio 5: Chiamata del livello di memorizzazione nella cache dal livello 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'utilizzo 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. Dallo smart tag gridView creare un nuovo 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 Drop-Down oggetto business (fare clic per visualizzare l'immagine a dimensione intera)
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'unico UpdateProduct overload. 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 dimensione intera)
Al termine della procedura guidata, Visual Studio imposterà la proprietà original_{0} ObjectDataSource su OldValuesParameterFormatString e aggiungerà i campi appropriati a GridView. Ripristinare il OldValuesParameterFormatString valore predefinito della 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 campi per i ProductNamecampi , CategoryNamee 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 è disponibile una pagina che usa il livello di memorizzazione nella cache. Per visualizzare la cache in azione, impostare punti di interruzione nei metodi e UpdateProduct della ProductsCL classe GetProducts() . Visitare la pagina in un browser ed esaminare il codice durante l'ordinamento e il paging per visualizzare i dati estratti dalla cache. Aggiornare quindi un record e notare che la cache viene invalidata e, di conseguenza, viene recuperata dal BLL quando i dati vengono rimbalzati in GridView.
Nota
Il livello di memorizzazione nella cache fornito nel download che accompagna questo articolo non è completo. Contiene una sola classe, ProductsCL, che sport solo una manciata di metodi. Inoltre, solo una singola pagina ASP.NET usa 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 presentazione devono passare a CL, che richiederebbe che le classi e i metodi cls trattassero tali classi e metodi nel livello BLL attualmente utilizzato dal livello presentazione.
Riepilogo
Anche se la memorizzazione nella cache può essere applicata al livello presentazione con i controlli SqlDataSource e ObjectDataSource di ASP.NET 2.0, idealmente le responsabilità di memorizzazione nella cache vengono delegate a un livello separato nell'architettura. In questa esercitazione è stato creato un livello di memorizzazione nella cache che risiede tra il livello presentazione e il livello della logica di business. Il livello di memorizzazione nella cache deve fornire lo stesso set di classi e metodi esistenti nel livello BLL e vengono chiamati dal livello presentazione.
Gli esempi del livello di memorizzazione nella cache illustrati in questa 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 tali 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 siano effettivamente necessari. 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, lavora 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 all'indirizzo mitchell@4GuysFromRolla.com. o tramite il suo blog, disponibile all'indirizzo http://ScottOnWriting.NET.
Grazie speciale a
Questa serie di esercitazioni è stata esaminata da molti revisori utili. Il revisore principale di questa esercitazione era Teresa Murphy. Si è interessati a esaminare i prossimi articoli MSDN? In tal caso, rilasciami una riga in mitchell@4GuysFromRolla.com.