Memorizzazione di dati nella cache con ObjectDataSource (C#)

di Scott Mitchell

Scaricare il PDF

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

Nell'informatica, la memorizzazione nella cache è il processo di acquisizione di dati o informazioni costose da ottenere e archiviare una copia di esso in una posizione più rapida per accedere. Per le applicazioni guidate dai dati, le query complesse e di grandi dimensioni utilizzano in genere la maggior parte del tempo di esecuzione dell'applicazione. Tali prestazioni dell'applicazione, quindi, possono essere spesso migliorate archiviando i risultati di query di database costose nella memoria dell'applicazione.

ASP.NET 2.0 offre un'ampia gamma di opzioni di memorizzazione nella cache. Un'intera pagina Web o un markup di un controllo utente renderizzato può essere memorizzato nella cache dell'output. 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 il caching dell'output. Per un'analisi dettagliata della memorizzazione nella cache dell'output, vedere Memorizzazione nella cache dell'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, esamineremo la cache dei dati al livello della logica di business.

Concetti chiave relativi alla memorizzazione nella cache

La memorizzazione nella cache può migliorare notevolmente le prestazioni e la scalabilità complessive di un'applicazione prendendo dati costosi da generare e archiviare una copia 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 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 uno dei due elementi seguenti:

• I criteri basati sul tempo possono essere aggiunti alla cache per una durata assoluta o variabile. 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 variabile, 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 le dipendenze della cache SQL, che consentono agli sviluppatori di aggiungere un elemento alla cache e rimuoverlo quando i dati del database sottostanti vengono modificati. Nelle prossime esercitazioni sull'uso delle dipendenze della cache SQL verranno esaminate le dipendenze della cache SQL.

Indipendentemente dai criteri di rimozione specificati, un elemento nella cache può essere recuperato prima che siano stati soddisfatti i criteri basati sul tempo o sulle dipendenze. Se la cache ha raggiunto la capacità, è necessario rimuovere gli elementi esistenti prima che possano essere aggiunti nuovi elementi. Di conseguenza, quando si lavora a livello di codice con i dati memorizzati nella cache, è fondamentale presupporre sempre che i dati memorizzati nella cache non siano presenti. Esamineremo il modello da usare per accedere programmaticamente ai dati dalla cache nel nostro prossimo tutorial, Memorizzazione nella Cache dei Dati nell'Architettura.

La memorizzazione nella cache offre un mezzo economico per ottenere prestazioni migliori 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, una cattiva progettazione probabilmente ti tornerà contro, quindi naturalmente dovresti impegnarti a progettare correttamente le tue applicazioni. Tuttavia, se è sufficiente ottenere prestazioni sufficienti oggi, 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 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 se 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 Caching for Performance (Memorizzazione nella cache per le prestazioni ) di ASP.NET 2.0 QuickStart Tutorials (Esercitazioni introduttive su 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 del 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.aspx
• ObjectDataSource.aspx
• FromTheArchitecture.aspx
• AtApplicationStartup.aspx
• SqlCacheDependencies.aspx

Figura 1: Aggiungere le pagine ASP.NET per le esercitazioni Caching-Related

Come nelle altre cartelle, Default.aspx nella cartella Caching elenca 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 da Esplora soluzioni nella visualizzazione di progettazione della pagina.

Figura 2: Figura 2: Aggiungere il controllo utente a SectionLevelTutorialListing.ascx (Default.aspx a dimensione intera)

Infine, aggiungere queste pagine come voci nel Web.sitemap file. In particolare, aggiungere il markup seguente dopo lavorare con 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, dedica qualche minuto per visitare il 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 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 finestra di progettazione, 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 (ProductsBLL 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: Imposta la lista della scheda UPDATE Drop-Down sulla sovraccarica appropriata UpdateProduct (clicca per visualizzare l'immagine a schermo intero)

Impostare infine 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à OldValuesParameterFormatString dell'ObjectDataSource su original_{0}. Come illustrato nell'esercitazione Panoramica sull'inserimento, l'aggiornamento e l'eliminazione di 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, CategoryName e UnitPrice BoundFields. Aggiornare quindi le HeaderText proprietà di ognuno di questi BoundFields, aggiornandole rispettivamente a Product, Category e Price. Poiché il ProductName campo è obbligatorio, convertire BoundField in un oggetto TemplateField e aggiungere un oggetto RequiredFieldValidator a EditItemTemplate. Analogamente, convertire BoundField UnitPrice in un oggetto TemplateField e aggiungere un Oggetto 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 di modifica.

Rendi GridView modificabile selezionando la casella di controllo Abilita modifica nel tag intelligente di GridView. Selezionare anche le caselle di controllo Abilita paging e Abilita ordinamento.

Annotazioni

È necessaria una revisione di come personalizzare l'interfaccia di modifica di GridView? In tal caso, fate riferimento al tutorial Personalizzare l'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. Prenditi un momento per testare la funzionalità della pagina: ordina i risultati, scorri attraverso le pagine e modifica un record.

Figura 7: Il nome, la categoria e il prezzo di ciascun prodotto sono elencati in un controllo di GridView ordinabile, paginabile, modificabile (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 di ProductsBLL livello della logica di business e chiama il suo metodo GetProducts(), che a sua volta chiama il metodo ProductsTableAdapter di GetProducts() livello di accesso ai dati. Il metodo DAL si connette al database Northwind ed esegue la query configurata SELECT . Questi dati vengono quindi restituiti al DAL, che li confeziona in un NorthwindDataTable. L'oggetto DataTable viene restituito al BLL, che lo restituisce all'oggetto ObjectDataSource, che lo restituisce a GridView. GridView crea quindi un GridViewRow oggetto per ogni DataRow oggetto in 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 essere associato 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, quando si ordina GridView o quando si modificano i dati di GridView tramite le relative interfacce di modifica o eliminazione predefinite. Se lo stato di visualizzazione del GridView è disabilitato, il GridView verrà ricaricato a ogni postback. GridView può anche essere rilegato esplicitamente ai dati chiamando il metodo DataBind() relativo.

Per apprezzare appieno la frequenza con cui i dati vengono recuperati dal database, è possibile visualizzare un messaggio che indica quando i dati vengono recuperati di nuovo. Aggiungere una etichetta Web di controllo sopra il GridView denominato ODSEvents. Cancellare la Text proprietà e impostarne la EnableViewState proprietà su false. Sotto l'etichetta, aggiungere un controllo Web di tipo pulsante 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 Selecting viene generato prima che l'oggetto sottostante sia creato e il suo metodo configurato venga 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, il Label visualizzerà il testo evento di selezione attivato.

Visitare questa pagina in un browser. Quando la pagina viene visitata per la prima volta, viene visualizzato il testo Evento di selezione attivato. 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 dal relativo stato di visualizzazione e pertanto non si rivolge a ObjectDataSource per i relativi dati. Tuttavia, l'ordinamento, il paging o la modifica dei dati fanno sì che il GridView si riassoci di nuovo all'origine dati, e quindi viene nuovamente visualizzato il testo generato dall'evento Selecting.

Figura 9: Ogni volta che il GridView viene nuovamente associato alla sua origine dati, viene visualizzato l'evento Selecting attivato (clicca per vedere l'immagine a dimensione intera)

Figura 10: Se si fa clic sul pulsante Postback, GridView viene ricostruito dal suo stato di visualizzazione (fare clic per visualizzare l'immagine a dimensione intera)

Può sembrare inefficiente recuperare i dati del database ogni volta che vengono suddivisi in pagine 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 true per 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 solo i dati se EnableCaching è true e CacheDuration è impostato su un valore maggiore di zero.
• CacheExpirationPolicy può essere impostato su Absolute o Sliding. Se Absolute, ObjectDataSource memorizza nella cache i dati recuperati per CacheDuration secondi; se Sliding, i dati scadono solo dopo che non è stato eseguito l'accesso per CacheDuration secondi. 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 scadendo il suo CacheKeyDependency associato. 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 i ProductsDataSource dati nella cache per 30 secondi su scala assoluta. Impostare la proprietà EnableCaching ObjectDataSource su true e la proprietà CacheDuration su 30. Lasciare la CacheExpirationPolicy proprietà impostata sul valore predefinito, Absolute.

Figura 11: Configurare ObjectDataSource per memorizzare i dati nella cache per 30 secondi (fare clic per visualizzare l'immagine a dimensione intera)

Salvare le modifiche e rivedere questa pagina in un browser. Il testo generato dall'evento Selecting verrà visualizzato quando si visita la pagina, perché inizialmente i dati non si trovano nella cache. Tuttavia, i postback successivi attivati facendo clic sul pulsante Postback, durante l'ordinamento, paging o facendo clic sui pulsanti Modifica o Annulla non mostrano nuovamente il testo visualizzato 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 che sono trascorsi 30 secondi o dopo aver cliccato sul pulsante Aggiorna, ordinare, effettuare il paging o cliccare sui pulsanti Modifica o Annulla farà sì che l'ObjectDataSource ottenga i dati dal suo oggetto sottostante, visualizzando il testo 'evento Selecting attivato' quando l'evento Selecting viene attivato. Questi risultati restituiti vengono reinsediati nella cache dei dati.

Annotazioni

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, è possibile che i dati aggiunti alla cache da ObjectDataSource siano stati ripuliti. 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 attivato dall'evento Selecting viene visualizzato sullo schermo, è dovuto al fatto che i dati non erano presenti nella cache e devono essere recuperati dall'oggetto sottostante. Quando questo testo non è presente, tuttavia, ciò è perché i dati erano disponibili dalla cache. Quando i dati vengono restituiti dalla cache non viene eseguita 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 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 inserisce i dati recuperati nella cache, ObjectDataSource utilizza un valore della chiave della cache che include: i valori delle proprietà CacheDuration e CacheExpirationPolicy; il tipo di oggetto business sottostante utilizzato da ObjectDataSource, specificato tramite la proprietà TypeName (ProductsBLL, in questo esempio); il valore della proprietà SelectMethod e il nome e i valori dei parametri nella raccolta SelectParameters; e i valori delle sue proprietà StartRowIndex e MaximumRows, che sono utilizzati nell'implementazione del paging personalizzato .

La creazione del valore della chiave della cache come combinazione di queste proprietà garantisce una voce di cache univoca in quanto questi valori si modificano. 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, con un CategoryID valore pari a 1. Se ObjectDataSource ha memorizzato nella cache i risultati senza considerare i SelectParameters valori, quando un altro utente è arrivato 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 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 metodi Insert, Update o Delete. Ciò consente di 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 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 appena eseguito uno script che modifica alcuni dei record nel database.

Questo scenario potrebbe anche svolgersi 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, TypeName, SelectMethode così via). Se sono presenti due ObjectDataSource che usano 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 servita dalla cache. Vi invito a creare pagine per presentare questa funzionalità. Creare una pagina che visualizzi un GridView modificabile che estrae i dati da un ObjectDataSource configurato per usare la cache e per ottenere dati dal metodo della classe ProductsBLLGetProducts(). Aggiungi un altro GridView modificabile e un ObjectDataSource a questa pagina (o un'altra), ma fai in modo che questo secondo ObjectDataSource utilizzi il metodo GetProductsByCategoryID(categoryID). Poiché le due proprietà ObjectDataSources SelectMethod differiscono, ognuna avrà valori memorizzati nella cache. Se si modifica un prodotto in una griglia, alla prossima associazione dei dati all'altra griglia (tramite paginazione, ordinamento e così via), continuerà a utilizzare i dati memorizzati nella cache e non rifletterà la modifica effettuata 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 scadenze più brevi per gli scenari in cui l'aggiornamento dei dati è importante. Se i dati non aggiornati non sono accettabili, rinuncia alla memorizzazione nella cache o usa le dipendenze della cache SQL, presupponendo che si tratti di dati del database memorizzati nella cache. In un'esercitazione futura verranno esaminate le dipendenze della cache SQL.

Riassunto

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 le funzionalità di memorizzazione nella cache in un livello separato dell'architettura. A tale scopo, è 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.

Buon programmatori!

Altre informazioni

Per altre informazioni sugli argomenti illustrati in questa esercitazione, vedere le risorse seguenti:

• ASP.NET Caching: 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, ha lavorato con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, formatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2.0 in 24 ore. Può essere raggiunto a mitchell@4GuysFromRolla.com.

Grazie speciale a

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

Avanti