Memorizzazione di dati nella cache con ObjectDataSource (C#)
La memorizzazione nella cache può significare la differenza tra un'applicazione Web lenta e veloce. Questa esercitazione è la prima di quattro che esamina in dettaglio la memorizzazione nella cache in ASP.NET. Informazioni sui concetti chiave della memorizzazione nella cache e su come applicare la memorizzazione nella cache al livello presentazione tramite il controllo ObjectDataSource.
Introduzione
In ambito informatico, la memorizzazione nella cache è il processo di acquisizione di dati o informazioni dispendiose da ottenere e archiviare una copia di tali dati in una posizione più rapida da accedere. Per le applicazioni basate sui dati, le query complesse e di grandi dimensioni usano in genere la maggior parte del tempo di esecuzione dell'applicazione. Tali prestazioni di un'applicazione possono quindi essere migliorate archiviando i risultati di query di database dispendiose nella memoria dell'applicazione.
ASP.NET 2.0 offre un'ampia gamma di opzioni di memorizzazione nella cache. È possibile memorizzare nella cache un'intera pagina Web o un markup sottoposto a rendering del controllo utente. I controlli ObjectDataSource e SqlDataSource forniscono anche funzionalità di memorizzazione nella cache, consentendo così la memorizzazione nella cache dei dati a livello di controllo. E ASP.NET cache dei dati fornisce un'API di memorizzazione nella cache avanzata che consente agli sviluppatori di pagine di memorizzare nella cache gli oggetti a livello di codice. In questa esercitazione e nelle tre successive verranno esaminate le funzionalità di memorizzazione nella cache di ObjectDataSource e la cache dei dati. Si esaminerà anche come memorizzare nella cache i dati a livello di applicazione all'avvio e come mantenere aggiornati i dati memorizzati nella cache tramite l'uso delle dipendenze della cache SQL. Queste esercitazioni non esplorano la memorizzazione nella cache dell'output. Per un'analisi dettagliata della memorizzazione nella cache dell'output, vedere Memorizzazione nella cache di output in ASP.NET 2.0.
La memorizzazione nella cache può essere applicata in qualsiasi punto dell'architettura, dal livello di accesso ai dati fino al livello presentazione. In questa esercitazione verrà esaminata l'applicazione della memorizzazione nella cache al livello presentazione tramite il controllo ObjectDataSource. Nell'esercitazione successiva verranno esaminati i dati di memorizzazione nella cache a livello di logica di business.
Concetti relativi alla memorizzazione nella cache delle chiavi
La memorizzazione nella cache può migliorare notevolmente le prestazioni e la scalabilità complessive di un'applicazione prendendo i dati dispendiosi da generare e archiviarne una copia in una posizione accessibile in modo più efficiente. Poiché la cache contiene solo una copia dei dati effettivi, sottostanti, può diventare obsoleta o obsoleta, se i dati sottostanti cambiano. Per risolvere questo problema, uno sviluppatore di pagine può indicare i criteri in base ai quali l'elemento della cache verrà rimosso dalla cache, usando:
- I criteri basati sul tempo possono essere aggiunti alla cache per una durata assoluta o scorrevole. Ad esempio, uno sviluppatore di pagine può indicare una durata di 60 secondi. Con una durata assoluta, l'elemento memorizzato nella cache viene rimosso 60 secondi dopo l'aggiunta alla cache, indipendentemente dalla frequenza con cui è stato eseguito l'accesso. Con una durata scorrevole, l'elemento memorizzato nella cache viene rimosso 60 secondi dopo l'ultimo accesso.
- I criteri basati sulle dipendenze possono essere associati a una dipendenza quando aggiunti alla cache. Quando la dipendenza dell'elemento viene modificata, viene rimossa dalla cache. La dipendenza può essere un file, un altro elemento della cache o una combinazione dei due. ASP.NET 2.0 consente anche alle dipendenze della cache SQL, che consentono agli sviluppatori di aggiungere un elemento alla cache e di rimuoverlo quando cambiano i dati del database sottostanti. Verranno esaminate le dipendenze della cache SQL nell'esercitazione prossima sull'uso delle dipendenze della cache SQL .
Indipendentemente dai criteri di rimozione specificati, un elemento nella cache può essere scavenged prima che siano stati soddisfatti i criteri basati sul tempo o basati sulle dipendenze. Se la cache ha raggiunto la capacità, è necessario rimuovere gli elementi esistenti prima di aggiungerli nuovi. Di conseguenza, quando si lavora a livello di codice con i dati memorizzati nella cache, è fondamentale presupporre che i dati memorizzati nella cache non siano presenti. Si esaminerà il modello da usare per accedere ai dati dalla cache a livello di codice nell'esercitazione successiva, memorizzazione nella cache dei dati nell'architettura.
La memorizzazione nella cache offre un mezzo economico per l'esecuzione di una sequenza di prestazioni da un'applicazione. Come Steven Smith descrive nel suo articolo ASP.NET memorizzazione nella cache: tecniche e procedure consigliate:
La memorizzazione nella cache può essere un buon modo per ottenere prestazioni sufficienti senza richiedere molto tempo e analisi. La memoria è economica, quindi se è possibile ottenere le prestazioni necessarie memorizzando nella cache l'output per 30 secondi invece di trascorrere un giorno o una settimana cercando di ottimizzare il codice o il database, eseguire la soluzione di memorizzazione nella cache (presupponendo che i dati precedenti di 30 secondi siano ok) e procedere. Alla fine, la progettazione scadente probabilmente si raggiungerà, quindi naturalmente è consigliabile provare a progettare correttamente le applicazioni. Tuttavia, se è sufficiente ottenere prestazioni sufficienti, la memorizzazione nella cache può essere un ottimo [approccio], acquistando il tempo necessario per effettuare il refactoring dell'applicazione in un secondo momento quando si ha il tempo necessario per farlo.
Anche se la memorizzazione nella cache può offrire miglioramenti apprezzabili delle prestazioni, non è applicabile in tutte le situazioni, ad esempio con applicazioni che usano dati in tempo reale, con aggiornamento frequente o in cui anche i dati non aggiornati di breve durata sono inaccettabili. Tuttavia, per la maggior parte delle applicazioni, è consigliabile usare la memorizzazione nella cache. Per altre informazioni sulla memorizzazione nella cache in ASP.NET 2.0, vedere la sezione Memorizzazione nella cache per le prestazionidell'esercitazione introduttiva di ASP.NET 2.0.
Passaggio 1: Creazione delle pagine Web di memorizzazione nella cache
Prima di iniziare l'esplorazione delle funzionalità di memorizzazione nella cache di ObjectDataSource, è necessario prima di tutto creare le pagine ASP.NET nel progetto di sito Web che saranno necessarie per questa esercitazione e le tre successive. Per iniziare, aggiungere una nuova cartella denominata Caching. Aggiungere quindi le pagine di ASP.NET seguenti a tale cartella, assicurandosi di associare ogni pagina alla Site.master pagina master:
Default.aspxObjectDataSource.aspxFromTheArchitecture.aspxAtApplicationStartup.aspxSqlCacheDependencies.aspx
Figura 1: Aggiungere le pagine ASP.NET per le esercitazioni Caching-Related
Come nelle altre cartelle, Default.aspx nella Caching cartella verranno elencate le esercitazioni nella relativa sezione. Tenere presente che il SectionLevelTutorialListing.ascx controllo utente fornisce questa funzionalità. Aggiungere quindi questo controllo utente a Default.aspx trascinandolo dal Esplora soluzioni nella visualizzazione Struttura della pagina.
Figura 2: Figura 2: Aggiungere il controllo utente a Default.aspx (fare clic per visualizzare l'immagineSectionLevelTutorialListing.ascx a dimensione intera)
Infine, aggiungere queste pagine come voci al Web.sitemap file. In particolare, aggiungere il markup seguente dopo l'uso dei dati <siteMapNode>binari:
<siteMapNode title="Caching" url="~/Caching/Default.aspx"
description="Learn how to use the caching features of ASP.NET 2.0.">
<siteMapNode url="~/Caching/ObjectDataSource.aspx"
title="ObjectDataSource Caching"
description="Explore how to cache data directly from the
ObjectDataSource control." />
<siteMapNode url="~/Caching/FromTheArchitecture.aspx"
title="Caching in the Architecture"
description="See how to cache data from within the
architecture." />
<siteMapNode url="~/Caching/AtApplicationStartup.aspx"
title="Caching Data at Application Startup"
description="Learn how to cache expensive or infrequently-changing
queries at the start of the application." />
<siteMapNode url="~/Caching/SqlCacheDependencies.aspx"
title="Using SQL Cache Dependencies"
description="Examine how to have data automatically expire from the
cache when its underlying database data is modified." />
</siteMapNode>
Dopo l'aggiornamento Web.sitemap, dedicare qualche minuto alla visualizzazione del sito Web delle esercitazioni tramite un browser. Il menu a sinistra include ora gli elementi per le esercitazioni sulla memorizzazione nella cache.
Figura 3: La mappa del sito include ora le voci per le esercitazioni sulla memorizzazione nella cache
Passaggio 2: Visualizzazione di un elenco di prodotti in una pagina Web
Questa esercitazione illustra come usare le funzionalità di memorizzazione nella cache predefinite del controllo ObjectDataSource. Prima di poter esaminare queste funzionalità, è necessario prima di tutto una pagina da cui lavorare. Creare una pagina Web che usa un controllo GridView per elencare le informazioni sul prodotto recuperate da ObjectDataSource dalla ProductsBLL classe .
Per iniziare, aprire la ObjectDataSource.aspx pagina nella Caching cartella . Trascinare un controllo GridView dalla casella degli strumenti nella Designer, impostarne la ID proprietà su Productse, dallo smart tag, scegliere di associarlo a un nuovo controllo ObjectDataSource denominato ProductsDataSource. Configurare ObjectDataSource in modo che funzioni con la ProductsBLL classe .
Figura 4: Configurare ObjectDataSource per l'uso della classe (fare clic per visualizzare l'immagineProductsBLL a dimensione intera)
Per questa pagina, è possibile creare un controllo GridView modificabile in modo da poter esaminare cosa accade quando i dati memorizzati nella cache in ObjectDataSource vengono modificati tramite l'interfaccia di GridView. Lasciare l'elenco a discesa nella scheda SELECT impostato sul valore predefinito, GetProducts(), ma modificare l'elemento selezionato nella scheda UPDATE impostando l'overload UpdateProduct che accetta productName, unitPricee productID come parametri di input.
Figura 5: Impostare l'elenco Drop-Down scheda UPDATE sull'overload appropriato UpdateProduct (fare clic per visualizzare l'immagine a dimensione intera)
Infine, impostare gli elenchi a discesa nelle schede INSERT e DELETE su (Nessuno) e fare clic su Fine. Al termine della procedura guidata Configura origine dati, Visual Studio imposta la proprietà original_{0}ObjectDataSource su OldValuesParameterFormatString . Come illustrato nell'esercitazione Panoramica dell'inserimento, dell'aggiornamento e dell'eliminazione dei dati , questa proprietà deve essere rimossa dalla sintassi dichiarativa o impostata di nuovo sul valore predefinito, {0}, per consentire al flusso di lavoro di aggiornamento di procedere senza errori.
Inoltre, al completamento della procedura guidata Visual Studio aggiunge un campo a GridView per ognuno dei campi dati del prodotto. Rimuovere tutti gli elementi tranne ProductName, CategoryNamee UnitPrice BoundFields. Aggiornare quindi le HeaderText proprietà di ognuno di questi BoundFields rispettivamente in Product, Category e Price. Poiché il ProductName campo è obbligatorio, convertire BoundField in un campo Template e aggiungere un oggetto RequiredFieldValidator a EditItemTemplate. Analogamente, convertire BoundField UnitPrice in un Campo Modello e aggiungere un CompareValidator per assicurarsi che il valore immesso dall'utente sia un valore di valuta valido maggiore o uguale a zero. Oltre a queste modifiche, è possibile eseguire qualsiasi modifica estetica, ad esempio allineando a destra il UnitPrice valore o specificando la formattazione per il UnitPrice testo nelle interfacce di sola lettura e modifica.
Rendere modificabile GridView selezionando la casella di controllo Abilita modifica nella smart tag gridView. Selezionare anche le caselle di controllo Abilita paging e Abilita ordinamento.
Nota
È necessaria una revisione di come personalizzare l'interfaccia di modifica di GridView? In tal caso, fare riferimento all'esercitazione Personalizzazione dell'interfaccia di modifica dei dati .
Figura 6: Abilitare il supporto di GridView per la modifica, l'ordinamento e il paging (fare clic per visualizzare l'immagine a dimensione intera)
Dopo aver apportato queste modifiche a GridView, 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:TextBox>
<asp:RequiredFieldValidator
ID="RequiredFieldValidator1" Display="Dynamic"
ControlToValidate="ProductName" SetFocusOnError="True"
ErrorMessage="You must provide a name for the product."
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"
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" runat="server"
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="ProductsBLL" UpdateMethod="UpdateProduct">
<UpdateParameters>
<asp:Parameter Name="productName" Type="String" />
<asp:Parameter Name="unitPrice" Type="Decimal" />
<asp:Parameter Name="productID" Type="Int32" />
</UpdateParameters>
</asp:ObjectDataSource>
Come illustrato nella figura 7, GridView modificabile elenca il nome, la categoria e il prezzo di ognuno dei prodotti nel database. Per testare la funzionalità della pagina, ordinare i risultati, sfogliarli e modificare un record.
Figura 7: Ogni nome, categoria e prezzo del prodotto è elencato in un oggetto Ordinabile, Modificabile GridView (Fare clic per visualizzare l'immagine full-size)
Passaggio 3: Analisi quando objectDataSource richiede dati
Products GridView recupera i dati da visualizzare richiamando il Select metodo objectDataSourceProductsDataSource. Questo oggetto ObjectDataSource crea un'istanza della classe business logic ProductsBLL layer e chiama il GetProducts() relativo metodo, che a sua volta chiama il metodo s del GetProducts() livello di ProductsTableAdapter accesso dati. Il metodo DAL si connette al database Northwind e genera la query configurata SELECT . Questi dati vengono quindi restituiti al DAL, che lo inserisce in un NorthwindDataTableoggetto . L'oggetto DataTable viene restituito al BLL, che lo restituisce all'oggetto ObjectDataSource, che lo restituisce in GridView. GridView crea quindi un GridViewRow oggetto per ogni DataRow oggetto in DataTable e ogni GridViewRow oggetto viene quindi eseguito il rendering nel codice HTML restituito al client e visualizzato nel browser del visitatore.
Questa sequenza di eventi si verifica ogni e ogni volta che GridView deve associare ai dati sottostanti. Ciò accade quando la pagina viene visitata per la prima volta, quando si passa da una pagina di dati a un'altra, quando si ordina GridView o quando si modificano i dati di GridView tramite la modifica predefinita o l'eliminazione di interfacce. Se lo stato di visualizzazione di GridView è disabilitato, GridView verrà rebound in ogni e ogni postback. GridView può anche essere rebound in modo esplicito ai dati chiamando il DataBind() relativo metodo.
Per apprezzare completamente la frequenza con cui i dati vengono recuperati dal database, consente di visualizzare un messaggio che indica quando i dati vengono recuperati di nuovo. Aggiungere un controllo Web Label sopra GridView denominato ODSEvents. Deselezionare la Text proprietà e impostare la relativa EnableViewState proprietà su false. Sotto l'etichetta aggiungere un controllo Web Button e impostarne la Text proprietà su Postback .
Figura 8: Aggiungere un'etichetta e un pulsante alla pagina sopra GridView (Fare clic per visualizzare l'immagine full-size)
Durante il flusso di lavoro di accesso ai dati, l'evento ObjectDataSource Selecting viene generato prima della creazione dell'oggetto sottostante e del relativo metodo configurato richiamato. Creare un gestore eventi per questo evento e aggiungere il codice seguente:
protected void ProductsDataSource_Selecting(object sender,
ObjectDataSourceSelectingEventArgs e)
{
ODSEvents.Text = "-- Selecting event fired";
}
Ogni volta che ObjectDataSource effettua una richiesta all'architettura per i dati, l'etichetta visualizzerà il testo Selezione evento attivato.
Visitare questa pagina in un browser. Quando la pagina viene visualizzata per la prima volta, viene visualizzato il testo Selezione dell'evento. Fare clic sul pulsante Postback e notare che il testo scompare (presupponendo che la proprietà GridView s EnableViewState sia impostata su true, l'impostazione predefinita). Ciò avviene perché, nel postback, GridView viene ricostruito dallo stato di visualizzazione e pertanto non si trasforma in ObjectDataSource per i dati. L'ordinamento, il paging o la modifica dei dati, tuttavia, causa la ribinazione di GridView nell'origine dati e quindi viene visualizzato nuovamente il testo selezionato.
Figura 9: ogni volta che GridView viene rebound all'origine dati, viene visualizzato l'evento Selezione dell'evento (Fare clic per visualizzare l'immagine a dimensioni complete)
Figura 10: facendo clic sul pulsante Postback, GridView viene ricostruito dallo stato di visualizzazione (fare clic per visualizzare l'immagine a dimensioni complete)
Può sembrare sprecato recuperare i dati del database ogni volta che i dati vengono impaginati o ordinati. Dopo tutto, poiché si usa il paging predefinito, ObjectDataSource ha recuperato tutti i record durante la visualizzazione della prima pagina. Anche se GridView non fornisce supporto per l'ordinamento e il paging, i dati devono essere recuperati dal database ogni volta che la pagina viene prima visitata da qualsiasi utente (e in ogni postback, se lo stato di visualizzazione è disabilitato). Tuttavia, se GridView mostra gli stessi dati a tutti gli utenti, queste richieste di database aggiuntive sono superflue. Perché non memorizzare nella cache i risultati restituiti dal GetProducts() metodo e associare GridView a tali risultati memorizzati nella cache?
Passaggio 4: Memorizzazione nella cache dei dati tramite ObjectDataSource
Impostando semplicemente alcune proprietà, ObjectDataSource può essere configurato per memorizzare automaticamente nella cache i dati recuperati nella cache dei dati ASP.NET. L'elenco seguente riepiloga le proprietà correlate alla cache di ObjectDataSource:
- EnableCaching deve essere impostato su per
trueabilitare la memorizzazione nella cache. Il valore predefinito èfalse. - CacheDuration la quantità di tempo, in secondi, che i dati vengono memorizzati nella cache. Il valore predefinito è 0. ObjectDataSource memorizza nella cache solo i dati se
EnableCachingètrueeCacheDurationviene impostato su un valore maggiore di zero. - CacheExpirationPolicy può essere impostato su
AbsoluteoSliding. SeAbsolute, ObjectDataSource memorizza nella cache i dati recuperati perCacheDurationsecondi; seSlidingi dati scadono solo dopo che non è stato eseguito l'accesso perCacheDurationsecondi. Il valore predefinito èAbsolute. - CacheKeyDependency usa questa proprietà per associare le voci della cache di ObjectDataSource a una dipendenza della cache esistente. Le voci di dati objectDataSource possono essere rimosse prematuramente dalla cache scadendo con il relativo oggetto associato
CacheKeyDependency. Questa proprietà è più comunemente usata per associare una dipendenza della cache SQL alla cache di ObjectDataSource, un argomento verrà illustrato in futuro usando dipendenze cache SQL .
Consente di configurare ObjectDataSource per memorizzare nella cache i ProductsDataSource dati per 30 secondi su una scala assoluta. Impostare la proprietà ObjectDataSource su EnableCaching e la relativa CacheDuration proprietà true su 30. Lasciare la CacheExpirationPolicy proprietà impostata sul valore predefinito, Absolute.
Figura 11: Configurare ObjectDataSource per memorizzare nella cache i dati per 30 secondi (fare clic per visualizzare l'immagine full-size)
Salvare le modifiche e rivedere questa pagina in un browser. Il testo Selezionato generato dall'evento verrà visualizzato quando si visita per la prima volta la pagina, come inizialmente i dati non si trovano nella cache. Tuttavia, i postback successivi attivati facendo clic sul pulsante Postback, ordinando, paging o facendo clic sui pulsanti Modifica o Annulla non vengono riprodotti il testo selezionato. Questo avviene perché l'evento viene generato solo quando ObjectDataSource ottiene i dati dall'oggetto sottostante. L'evento SelectingSelecting non viene generato se i dati vengono estratti dalla cache dei dati.
Dopo 30 secondi, i dati verranno rimossi dalla cache. I dati verranno rimossi anche dalla cache se vengono richiamati i metodi ObjectDataSource s Insert, Updateo Delete . Di conseguenza, dopo 30 secondi o il pulsante Update è stato fatto clic, ordinando, paging o facendo clic sui pulsanti Modifica o Annulla, l'oggetto ObjectDataSource otterrà i dati dal relativo oggetto sottostante, visualizzando il testo selezionato generato quando l'evento Selecting viene attivato. Questi risultati restituiti vengono inseriti nella cache dei dati.
Nota
Se viene visualizzato spesso il testo selezionato, anche quando si prevede che ObjectDataSource funzioni con i dati memorizzati nella cache, potrebbe essere dovuto a vincoli di memoria. Se la memoria disponibile non è sufficiente, i dati aggiunti alla cache da ObjectDataSource potrebbero essere stati scavengenti. Se ObjectDataSource non sembra essere memorizzato correttamente nella cache dei dati o memorizza nella cache solo i dati sporadicamente, chiudere alcune applicazioni per liberare memoria e riprovare.
La figura 12 illustra il flusso di lavoro di memorizzazione nella cache di ObjectDataSource. Quando viene visualizzato il testo Selezione evento generato sullo schermo, è perché i dati non erano nella cache e devono essere recuperati dall'oggetto sottostante. Quando questo testo manca, tuttavia, è perché i dati erano disponibili dalla cache. Quando i dati vengono restituiti dalla cache non sono presenti chiamate all'oggetto sottostante e, pertanto, nessuna query di database eseguita.
Figura 12: ObjectDataSource archivia e recupera i dati dalla cache dei dati
Ogni applicazione ASP.NET dispone di un'istanza della cache dei dati condivisa tra tutte le pagine e i visitatori. Ciò significa che i dati archiviati nella cache dei dati da ObjectDataSource vengono condivisi in modo analogo in tutti gli utenti che visitano la pagina. Per verificare questa operazione, aprire la ObjectDataSource.aspx pagina in un browser. Quando si visita per la prima volta la pagina, verrà visualizzato il testo selezionato dell'evento attivato (presupponendo che i dati aggiunti alla cache dai test precedenti siano stati rimossi). Aprire una seconda istanza del browser e copiare e incollare l'URL dalla prima istanza del browser al secondo. Nella seconda istanza del browser il testo selezionato generato dall'evento non viene visualizzato perché usa gli stessi dati memorizzati nella cache del primo.
Quando si inseriscono i dati recuperati nella cache, ObjectDataSource usa un valore di chiave della cache che include: CacheDuration i valori e CacheExpirationPolicy della proprietà e, il tipo dell'oggetto business sottostante usato da ObjectDataSource, specificato tramite la TypeName proprietà (ProductsBLL, in questo esempio); il valore della SelectMethod proprietà e il nome e i valori dei parametri dell'insieme SelectParameters e i valori StartRowIndexMaximumRows delle relative proprietà e che vengono usati durante l'implementazione di paging personalizzati.
La creazione del valore della chiave della cache come combinazione di queste proprietà garantisce una voce di cache univoca in quanto questi valori cambiano. Ad esempio, nelle esercitazioni precedenti è stato esaminato l'uso della ProductsBLL classe s GetProductsByCategoryID(categoryID), che restituisce tutti i prodotti per una categoria specificata. Un utente potrebbe venire alla pagina e visualizzare le bevande, che ha un valore pari a CategoryID 1. Se ObjectDataSource ha memorizzato nella cache i risultati senza considerare i SelectParameters valori, quando un altro utente è venuto nella pagina per visualizzare i condimenti mentre i prodotti bevande erano nella cache, vedono i prodotti bevande memorizzati nella cache anziché i condimenti. Variando la chiave della cache in base a queste proprietà, che includono i valori dell'oggetto SelectParameters, ObjectDataSource gestisce una voce di cache separata per bevande e condimenti.
Problemi relativi ai dati non aggiornati
ObjectDataSource rimuove automaticamente gli elementi dalla cache quando viene richiamato uno dei Insertmetodi , Updateo Delete . Ciò consente di proteggere i dati non aggiornati cancellando le voci della cache quando i dati vengono modificati tramite la pagina. Tuttavia, è possibile che un oggetto ObjectDataSource usi la memorizzazione nella cache per visualizzare ancora dati non aggiornati. Nel caso più semplice, può essere dovuto alla modifica dei dati direttamente all'interno del database. Forse un amministratore del database ha appena eseguito uno script che modifica alcuni dei record nel database.
Questo scenario potrebbe anche verificarsi in modo più sottile. Mentre ObjectDataSource rimuove gli elementi dalla cache quando viene chiamato uno dei metodi di modifica dei dati, gli elementi memorizzati nella cache rimossi sono per la combinazione specifica di valori di proprietà (CacheDuration, , TypeNameSelectMethode così via). Se sono presenti due ObjectDataSource che usano diversi SelectMethods o SelectParameters, ma possono comunque aggiornare gli stessi dati, un OggettoDataSource può aggiornare una riga e invalidare le proprie voci della cache, ma la riga corrispondente per il secondo OggettoDataSource verrà comunque gestita dalla cache. Ti consigliamo di creare pagine per mostrare questa funzionalità. Creare una pagina che visualizza un oggetto GridView modificabile che esegue il pull dei dati da un oggetto ObjectDataSource che usa la ProductsBLL memorizzazione nella cache ed è configurato per ottenere dati dal metodo della classe.GetProducts() Aggiungere un altro oggetto GridView modificabile e ObjectDataSource a questa pagina (o un altro), ma per questo secondo ObjectDataSource usare il GetProductsByCategoryID(categoryID) metodo . Poiché le due proprietà ObjectDataSources differiscono, ognuna avrà i propri valori memorizzati SelectMethod nella cache. Se si modifica un prodotto in una griglia, la prossima volta che si associano i dati all'altra griglia (tramite paging, ordinamento e così via), i dati memorizzati nella cache e non riflettono la modifica apportata dall'altra griglia.
In breve, usare solo le scadenze basate sul tempo se si è disposti ad avere il potenziale di dati non aggiornati e usare le scadenze più brevi per gli scenari in cui la freschezza dei dati è importante. Se i dati non aggiornati non sono accettabili, la memorizzazione nella cache o l'uso delle dipendenze della cache SQL ,presupponendo che si tratti di dati di database memorizzati nella cache. In un'esercitazione futura verranno esaminate le dipendenze della cache SQL.
Riepilogo
In questa esercitazione sono state esaminate le funzionalità di memorizzazione nella cache predefinite di ObjectDataSource. Impostando semplicemente alcune proprietà, è possibile indicare a ObjectDataSource di memorizzare nella cache i risultati restituiti dall'oggetto specificato SelectMethod nella cache dei dati ASP.NET. Le CacheDuration proprietà e CacheExpirationPolicy indicano la durata della memorizzazione nella cache dell'elemento e se si tratta di una scadenza assoluta o scorrevole. La CacheKeyDependency proprietà associa tutte le voci della cache di ObjectDataSource a una dipendenza della cache esistente. Può essere usato per rimuovere le voci di ObjectDataSource dalla cache prima del raggiungimento della scadenza basata sul tempo e viene in genere usato con le dipendenze della cache SQL.
Poiché ObjectDataSource memorizza semplicemente i valori nella cache dei dati, è possibile replicare la funzionalità predefinita di ObjectDataSource a livello di codice. Non ha senso eseguire questa operazione a livello di presentazione, poiché ObjectDataSource offre questa funzionalità predefinita, ma è possibile implementare funzionalità di memorizzazione nella cache in un livello separato dell'architettura. A tale scopo, è necessario ripetere la stessa logica usata da ObjectDataSource. Si esaminerà come usare a livello di codice la cache dei dati dall'interno dell'architettura nell'esercitazione successiva.
Buon programmatori!
Altre informazioni
Per altre informazioni sugli argomenti descritti in questa esercitazione, vedere le risorse seguenti:
- ASP.NET memorizzazione nella cache: tecniche e procedure consigliate
- Guida all'architettura di memorizzazione nella cache per le applicazioni .NET Framework
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.
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per