Memorizzazione di dati nella cache con ObjectDataSource (VB)
La memorizzazione nella cache può significare la differenza tra un'applicazione Web lenta e veloce. Questa esercitazione è la prima di quattro che esaminano in dettaglio la memorizzazione nella cache in ASP.NET. Informazioni sui concetti principali della memorizzazione nella cache e su come applicare la memorizzazione nella cache al livello presentazione tramite il controllo ObjectDataSource.
Introduzione
In informatica la memorizzazione nella cache è il processo di acquisizione di dati o informazioni costose per ottenere e archiviare una copia di esso in una posizione più rapida per 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, quindi, possono spesso essere migliorate archiviando i risultati delle query di database costose nella memoria dell'applicazione.
ASP.NET 2.0 offre diverse opzioni di memorizzazione nella cache. È possibile memorizzare nella cache un'intera pagina Web o il markup di Controllo utente con rendering. I controlli ObjectDataSource e SqlDataSource forniscono anche funzionalità di memorizzazione nella cache, consentendo di memorizzare nella cache i dati a livello di controllo. E ASP.NET cache dei dati offre un'API di memorizzazione nella cache avanzata che consente agli sviluppatori di pagine di memorizzare nella cache a livello di codice gli oggetti. In questa esercitazione e le tre successive verranno esaminate le funzionalità di memorizzazione nella cache di ObjectDataSource e la cache dei dati. Verranno inoltre illustrati 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 di output. Per un'analisi dettagliata della memorizzazione nella cache degli output, vedere Memorizzazione nella cache di output in ASP.NET 2.0.
La memorizzazione nella cache può essere applicata in qualsiasi posizione nell'architettura, dal livello di accesso ai dati fino al livello di 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 nel livello della logica di business.
Concetti di memorizzazione nella cache delle chiavi
La memorizzazione nella cache può migliorare notevolmente le prestazioni complessive e la scalabilità dell'applicazione prendendo i dati che sono costosi per generare e archiviare una copia di esso in una posizione a cui è possibile accedere in modo più efficiente. Poiché la cache contiene solo una copia dei dati effettivi, sottostanti, può diventare obsoleta o non aggiornata, se i dati sottostanti cambiano. Per combattere questo problema, uno sviluppatore di pagine può indicare i criteri in base ai quali l'elemento della cache verrà rimosso dalla cache, usando entrambi:
- 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, ad esempio, 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 un elemento quando aggiunti alla cache. Quando la dipendenza dell'elemento cambia, 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 eliminarli quando i dati del database sottostante cambiano. Verranno esaminate le dipendenze della cache SQL nell'esercitazione Uso delle dipendenze cache SQL imminenti .
Indipendentemente dai criteri di rimozione specificati, un elemento nella cache può essere scavendato prima che siano stati soddisfatti i criteri basati sul tempo o basati sulle dipendenze. Se la cache ha raggiunto la capacità, gli elementi esistenti devono essere rimossi prima che possano essere aggiunti nuovi elementi. Di conseguenza, quando si lavora a livello di codice con i dati memorizzati nella cache, è fondamentale che i dati memorizzati nella cache non siano presenti. Verrà esaminato il modello da usare durante l'accesso 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 squezzare più prestazioni da un'applicazione. Come Steven Smith si articola 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 anziché 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 spostarsi. Alla fine, la progettazione scarsa probabilmente si raggiungerà, quindi naturalmente si dovrebbe provare a progettare correttamente le applicazioni. Tuttavia, se è sufficiente ottenere prestazioni sufficienti oggi, la memorizzazione nella cache può essere un ottimo [approccio], acquistando tempo per eseguire il refactoring dell'applicazione in un secondo momento quando si ha il tempo di farlo.
Anche se la memorizzazione nella cache può fornire miglioramenti delle prestazioni apprezzabili, non è applicabile in tutte le situazioni, ad esempio con le applicazioni che usano dati in tempo reale, aggiornando di frequente i dati o dove anche i dati non aggiornati di breve durata non sono accettabili. Tuttavia, per la maggior parte delle applicazioni, la memorizzazione nella cache deve essere usata. Per altre informazioni sulla memorizzazione nella cache in ASP.NET 2.0, vedere la sezione Memorizzazione nella cache per le prestazioni dell'esercitazionedi avvio rapido ASP.NET 2.0.
Passaggio 1: Creazione della memorizzazione nella cache di pagine Web
Prima di iniziare l'esplorazione delle funzionalità di memorizzazione nella cache di ObjectDataSource, è prima necessario creare le pagine ASP.NET nel progetto del sito Web che sarà necessario per questa esercitazione e le tre successive. Iniziare aggiungendo 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 dalla Esplora soluzioni nella visualizzazione Progettazione della pagina.
Figura 2: Figura 2: Aggiungere il controllo utente a Default.aspx (fare clic per visualizzare l'immagineSectionLevelTutorialListing.ascx full-size)
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, passare un momento per visualizzare il sito Web delle esercitazioni tramite un browser. Il menu a sinistra include ora elementi per le esercitazioni di memorizzazione nella cache.
Figura 3: La mappa del sito include ora 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à, tuttavia, è prima necessario usare una pagina da cui lavorare. Consente di creare una pagina Web che usa GridView per elencare le informazioni sul prodotto recuperate da un OggettoDataSource dalla ProductsBLL classe.
Iniziare aprendo la ObjectDataSource.aspx pagina nella Caching cartella. Trascinare GridView dalla casella degli strumenti nella Designer, impostare la relativa ID proprietà su Productse, dal relativo smart tag, scegliere di associarlo a un nuovo controllo ObjectDataSource denominato ProductsDataSource. Configurare ObjectDataSource per l'uso della ProductsBLL classe.
Figura 4: Configurare ObjectDataSource per usare la classe (fare clic per visualizzare l'immagineProductsBLL full-size)
Per questa pagina, consente di creare un gridView modificabile in modo che sia possibile esaminare ciò che accade quando i dati memorizzati nella cache in ObjectDataSource vengono modificati tramite l'interfaccia di GridView s. Lasciare l'elenco a discesa nella scheda SELECT impostato sul valore predefinito, ma modificare l'elemento selezionato nella scheda UpdateProduct UPDATE nell'overload che accetta productName, GetProducts()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 dimensioni complete)
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 nuovamente sul relativo 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 ProductName, CategoryNamee UnitPrice BoundFields. Aggiornare quindi le HeaderText proprietà di ognuno di questi BoundFields rispettivamente a Product, Category e Price. Poiché il ProductName campo è obbligatorio, convertire BoundField in un ModelloField e aggiungere un oggetto RequiredFieldValidator all'oggetto EditItemTemplate. Analogamente, convertire BoundField UnitPrice in un ModelloField 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 relative interfacce di sola lettura e modifica.
Apportare la modifica di GridView selezionando la casella di controllo Abilita modifica nella smart tag di GridView. Selezionare anche le caselle di controllo Abilita paging e Abilita ordinamento.
Nota
È necessario esaminare 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 full-size)
Dopo aver apportato queste modifiche a GridView, il markup dichiarativo gridView e ObjectDataSource deve 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, la pagina e modificare un record.
Figura 7: Ogni nome, categoria e prezzo del prodotto è elencato in un controllo Ordinabile, Impaginabile, Modificabile GridView (fare clic per visualizzare l'immagine a dimensione intera)
Passaggio 3: Analisi di quando ObjectDataSource richiede dati
Products GridView recupera i dati da visualizzare richiamando il Select metodo di ProductsDataSource ObjectDataSource. Questo ObjectDataSource crea un'istanza della classe del ProductsBLL livello della logica di business e chiama il relativo GetProducts() metodo, che a sua volta chiama il metodo del GetProducts() livello di ProductsTableAdapter accesso ai dati. Il metodo DAL si connette al database Northwind ed esegue la query configurata SELECT . Questi dati vengono quindi restituiti a DAL, che lo inserisce in un oggetto NorthwindDataTable. L'oggetto DataTable viene restituito al BLL, che lo restituisce a ObjectDataSource, che lo restituisce a GridView. GridView crea quindi un GridViewRow oggetto per ogni DataRow oggetto di DataTable e ogni GridViewRow oggetto viene infine sottoposto a rendering nel codice HTML restituito al client e visualizzato nel browser del visitatore.
Questa sequenza di eventi si verifica ogni volta che GridView deve eseguire il binding ai dati sottostanti. Ciò si verifica quando la pagina viene visitata per la prima volta, quando si passa da una pagina di dati a un'altra, durante l'ordinamento di GridView o quando si modificano i dati di GridView tramite le relative interfacce di modifica o eliminazione predefinite. Se lo stato di visualizzazione di GridView è disabilitato, GridView verrà rimbalzato anche su ogni postback. GridView può anche essere rimbalzato in modo esplicito ai dati chiamando il relativo DataBind() metodo.
Per apprezzare appieno la frequenza con cui i dati vengono recuperati dal database, è possibile visualizzare un messaggio che indica quando i dati vengono recuperati nuovamente. Aggiungere un controllo Web Etichetta sopra GridView denominato ODSEvents. Cancellare la proprietà Text e impostarne la 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 a dimensione intera)
Durante il flusso di lavoro di accesso ai dati, l'evento ObjectDataSource viene Selecting 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 Sub ProductsDataSource_Selecting(sender As Object, _
e As ObjectDataSourceSelectingEventArgs) _
Handles ProductsDataSource.Selecting
ODSEvents.Text = "-- Selecting event fired"
End Sub
Ogni volta che ObjectDataSource effettua una richiesta all'architettura per i dati, l'etichetta visualizzerà il testo Selecting event fired .
Visitare questa pagina in un browser. Quando la pagina viene visitata per la prima volta, viene visualizzato il testo Selezione evento generato. Fare clic sul pulsante Postback e notare che il testo scompare (presupponendo che la proprietà GridView sia EnableViewState impostata su True, l'impostazione predefinita). Ciò è dovuto al fatto che, al postback, GridView viene ricostruito dallo stato di visualizzazione e pertanto non si rivolge a ObjectDataSource per i dati. L'ordinamento, il paging o la modifica dei dati, tuttavia, determina la riassociazione di GridView all'origine dati e quindi viene nuovamente visualizzato il testo generato dall'evento Selecting.
Figura 9: Ogni volta che GridView viene rimbalzato nell'origine dati, viene visualizzato l'evento Selecting (Fare clic per visualizzare l'immagine a dimensione intera)
Figura 10: Se si fa clic sul pulsante Postback, GridView viene ricostruito dallo stato di visualizzazione (fare clic per visualizzare l'immagine a dimensione intera)
Può sembrare sprecato recuperare i dati del database ogni volta che i dati vengono sottoposti a paging 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 visitata per la prima volta 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
Trueper abilitare la memorizzazione nella cache. Il valore predefinito èFalse. - CacheDuration la quantità di tempo, in secondi, in cui i dati vengono memorizzati nella cache. Il valore predefinito è 0. ObjectDataSource memorizza nella cache i dati solo se
EnableCachingèTrueeCacheDurationè impostato su un valore maggiore di zero. - CacheExpirationPolicy può essere impostato su
AbsoluteoSliding. SeAbsolute, ObjectDataSource memorizza nella cache i dati recuperati perCacheDurationsecondi; seSliding, i 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 di ObjectDataSource possono essere rimosse prematuramente dalla cache in scadenza
CacheKeyDependency. Questa proprietà viene usata più comunemente per associare una dipendenza della cache SQL alla cache di ObjectDataSource, un argomento che verrà esaminato in futuro usando le dipendenze della cache SQL .
Configurare ObjectDataSource per memorizzare nella ProductsDataSource cache i dati per 30 secondi su scala assoluta. Impostare la proprietà ObjectDataSource su EnableCaching e la relativa CacheDuration proprietà su 30.True 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 a dimensione intera)
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, perché inizialmente i dati non si trovano nella cache. Tuttavia, i postback successivi attivati facendo clic sul pulsante Postback, l'ordinamento, il paging o facendo clic sui pulsanti Modifica o Annulla non visualizzano nuovamente il testo generato dall'evento Selecting. Questo avviene perché l'evento Selecting viene generato solo quando ObjectDataSource ottiene i dati dall'oggetto sottostante. L'evento Selecting 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 il superamento di 30 secondi o il pulsante Aggiorna è stato fatto clic, ordinando, paging o facendo clic sui pulsanti Modifica o Annulla, ObjectDataSource otterrà i dati dall'oggetto sottostante, visualizzando il testo generato dall'evento Selecting quando viene generato l'evento Selecting . Questi risultati restituiti vengono inseriti nuovamente nella cache dei dati.
Nota
Se viene visualizzato spesso il testo generato dall'evento Selecting, 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 scavenged. Se ObjectDataSource non sembra memorizzare correttamente nella cache i 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 il testo generato dall'evento Selecting viene visualizzato sullo schermo, è perché i dati non si trovavano nella cache e dovevano essere recuperati dall'oggetto sottostante. Quando questo testo non è presente, tuttavia, è perché i dati erano disponibili dalla cache. Quando i dati vengono restituiti dalla cache non è presente alcuna chiamata all'oggetto sottostante e pertanto non viene eseguita alcuna query di database.
Figura 12: ObjectDataSource archivia e recupera i dati dalla cache dei dati
Ogni applicazione ASP.NET ha una propria 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 a tutti gli utenti che visitano la pagina. Per verificarlo, aprire la ObjectDataSource.aspx pagina in un browser. Quando si visita per la prima volta la pagina, verrà visualizzato il testo generato dall'evento Selecting (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 generato dall'evento Selecting non viene visualizzato perché usa gli stessi dati memorizzati nella cache del primo.
Quando si inseriscono i dati recuperati nella cache, ObjectDataSource utilizza un valore della chiave della cache che include: i valori della CacheDuration proprietà e CacheExpirationPolicy , il tipo dell'oggetto business sottostante utilizzato da ObjectDataSource, specificato tramite la TypeName proprietà (ProductsBLLin questo esempio); il valore della SelectMethod proprietà e il nome e i valori dei parametri nell'insieme SelectParameters e i valori delle StartRowIndex relative proprietà e MaximumRows , utilizzato per l'implementazione del paging personalizzato.
La creazione del valore della chiave della cache come combinazione di queste proprietà garantisce una voce della cache univoca quando 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 bevande, che ha un valore CategoryID pari a 1. Se ObjectDataSource ha memorizzato nella cache i risultati senza considerare i SelectParameters valori, quando un altro utente è venuto alla pagina per visualizzare i condimenti mentre i prodotti delle bevande erano nella cache, vedranno i prodotti bevande memorizzati nella cache anziché i condimenti. Variando la chiave della cache in base a queste proprietà, che includono i valori di SelectParameters, ObjectDataSource mantiene una voce cache separata per bevande e condimenti.
Problemi relativi ai dati non aggiornati
ObjectDataSource rimuove automaticamente gli elementi dalla cache quando viene richiamato uno dei Insertrelativi metodi , Updateo Delete . In questo modo è possibile proteggersi da dati non aggiornati cancellando le voci della cache quando i dati vengono modificati tramite la pagina. Tuttavia, è possibile che objectDataSource usi la memorizzazione nella cache per visualizzare ancora i dati non aggiornati. Nel caso più semplice, può essere dovuto alla modifica dei dati direttamente all'interno del database. Ad esempio, un amministratore del database ha 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 valoriCacheDuration di proprietà (, TypeName, SelectMethode così via). Se si dispone di due ObjectDataSource che usano oggetti diversi SelectMethods o SelectParameters, ma possono comunque aggiornare gli stessi dati, un ObjectDataSource può aggiornare una riga e invalidare le proprie voci della cache, ma la riga corrispondente per il secondo ObjectDataSource verrà comunque gestita dalla cache. Ti invito a creare pagine per presentare questa funzionalità. Creare una pagina che visualizza un controllo GridView modificabile che estrae i dati da objectDataSource che usa la memorizzazione nella cache ed è configurato per ottenere dati dal ProductsBLL metodo della GetProducts() classe. Aggiungere un altro oggetto GridView modificabile e ObjectDataSource a questa pagina (o a un altro), ma per questo secondo ObjectDataSource usare il GetProductsByCategoryID(categoryID) metodo . Poiché le due proprietà ObjectDataSources SelectMethod differiscono, ognuna avrà i propri valori memorizzati nella cache. Se si modifica un prodotto in una griglia, la volta successiva si associano i dati all'altra griglia (tramite paging, ordinamento e così via), i dati precedenti, memorizzati nella cache e non riflettono la modifica apportata dall'altra griglia.
In breve, usare le scadenze basate sul tempo solo se si è disposti ad avere il potenziale di dati non aggiornati e usare le scadenze più brevi per gli scenari in cui l'aggiornamento dei dati è importante. Se i dati non aggiornati non sono accettabili, la memorizzazione nella cache di forgo o l'uso delle dipendenze della cache SQL (presupponendo che i dati del database vengano memorizzati nella cache). Verranno esaminate le dipendenze della cache SQL in un'esercitazione futura.
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 dalla cache dei dati specificata SelectMethod nella cache dei dati ASP.NET. Le CacheDuration proprietà e CacheExpirationPolicy indicano la durata memorizzata nella cache dell'elemento e se è una scadenza assoluta o scorrevole. La CacheKeyDependency proprietà associa tutte le voci della cache di ObjectDataSource a una dipendenza della cache esistente. Questa operazione può essere usata per rimuovere le voci di ObjectDataSource dalla cache prima che venga raggiunta la scadenza basata sul tempo e viene in genere usata con le dipendenze della cache SQL.
Poiché ObjectDataSource memorizza semplicemente nella cache dei dati i relativi valori, è possibile replicare la funzionalità predefinita objectDataSource. Non è consigliabile eseguire questa operazione a livello di presentazione, poiché ObjectDataSource offre questa funzionalità fuori dalla casella, ma è possibile implementare le funzionalità di memorizzazione nella cache in un livello separato dell'architettura. A tale scopo, sarà necessario ripetere la stessa logica usata da ObjectDataSource. Verrà illustrato come usare a livello di codice la cache dei dati dall'interno dell'architettura nell'esercitazione successiva.
Programmazione felice!
Altre informazioni
Per altre informazioni sugli argomenti illustrati in questa esercitazione, vedere le risorse seguenti:
- ASP.NET memorizzazione nella cache: tecniche e procedure consigliate
- Guida all'architettura di memorizzazione nella cache per applicazioni .NET Framework
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 Murphy. Interessati a esaminare i prossimi articoli MSDN? In tal caso, lasciami 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