Procedura dettagliata: memorizzazione dei dati di un'applicazione nella cache di un'applicazione WPF

  • Articolo

La memorizzazione nella cache consente di inserire i dati in memoria per l'accesso rapido. Quando accedono nuovamente ai dati, le applicazioni possono recuperarli dalla cache anziché dall'origine. In questo modo si possono ottenere migliori prestazioni e scalabilità. Inoltre, se si memorizzano i dati nella cache, questi sono accessibili anche quando l'origine dati è temporaneamente non disponibile.

.NET Framework fornisce classi che consentono di usare la memorizzazione nella cache nelle applicazioni .NET Framework. Queste classi si trovano nello spazio dei System.Runtime.Caching nomi .

Nota

Lo System.Runtime.Caching spazio dei nomi è nuovo in .NET Framework 4. Questo spazio dei nomi rende disponibile la memorizzazione nella cache per tutte le applicazioni .NET Framework. Nelle versioni precedenti di .NET Framework, la memorizzazione nella cache era disponibile solo nello spazio dei System.Web nomi e pertanto richiedeva una dipendenza dalle classi ASP.NET.

Questa procedura dettagliata illustra come usare la funzionalità di memorizzazione nella cache disponibile in .NET Framework come parte di un'applicazione Windows Presentation Foundation (WPF). Nella procedura dettagliata è possibile memorizzare nella cache il contenuto di un file di testo.

Di seguito vengono illustrate le attività incluse nella procedura dettagliata:

  • Creazione di un progetto di applicazione WPF.

  • Aggiunta di un riferimento a .NET Framework 4.

  • Inizializzazione di una cache.

  • Aggiunta di una voce della cache contenente il contenuto di un file di testo.

  • Specifica di un criterio di rimozione per la voce della cache.

  • Monitoraggio del percorso del file memorizzato nella cache e notifica all'istanza della cache delle modifiche apportate all'elemento monitorato.

Prerequisiti

Per completare questo scenario, saranno necessari gli elementi seguenti:

  • Visual Studio 2010.

  • File di testo che contiene una piccola quantità di testo. Verrà visualizzato il contenuto del file di testo in una finestra di messaggio. Il codice illustrato nella procedura dettagliata presuppone che si stia usando il file seguente:

    c:\cache\cacheText.txt

    Tuttavia, è possibile usare qualsiasi file di testo e apportare piccole modifiche al codice in questa procedura dettagliata.

Creazione di un progetto di applicazione WPF

Si inizierà creando un progetto di applicazione WPF.

Per creare un'applicazione WPF

  1. Avviare Visual Studio.

  2. Scegliere Nuovo dal menu File e quindi fare clic su Nuovo progetto.

    Verrà visualizzata la finestra di dialogo Nuovo progetto.

  3. In Modelli installati selezionare il linguaggio di programmazione da usare (Visual Basic o Visual C#).

  4. Nella finestra di dialogo Nuovo progetto selezionare Applicazione WPF.

    Nota

    Se non viene visualizzato il modello applicazione WPF, assicurarsi di avere come destinazione una versione di .NET Framework che supporta WPF. Nella finestra di dialogo Nuovo progetto selezionare .NET Framework 4 dall'elenco.

  5. Nella casella di testo Nome immettere un nome per il progetto. Ad esempio, è possibile immettere WPFCaching.

  6. Selezionare la casella di controllo Crea directory per soluzione.

  7. Fare clic su OK.

    La finestra di progettazione WPF viene aperta nella visualizzazione Progettazione e visualizza il file MainWindow.xaml. Visual Studio crea la cartella My Project , il file Application.xaml e il file MainWindow.xaml.

Destinazione di .NET Framework e aggiunta di un riferimento agli assembly di memorizzazione nella cache

Per impostazione predefinita, le applicazioni WPF hanno come destinazione il profilo client .NET Framework 4. Per usare lo System.Runtime.Caching spazio dei nomi in un'applicazione WPF, l'applicazione deve avere come destinazione .NET Framework 4 (non il profilo client .NET Framework 4) e deve includere un riferimento allo spazio dei nomi.

Il passaggio successivo consiste pertanto nel modificare la destinazione .NET Framework e aggiungere un riferimento allo spazio dei System.Runtime.Caching nomi .

Nota

La procedura per modificare la destinazione .NET Framework è diversa in un progetto Visual Basic e in un progetto Visual C#.

Per modificare .NET Framework di destinazione in Visual Basic

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto e quindi scegliere Proprietà.

    Viene visualizzata la finestra delle proprietà per l'applicazione.

  2. Fare clic sulla scheda Compila.

  3. Nella parte inferiore della finestra fare clic su Opzioni di compilazione avanzate....

    Viene visualizzata la finestra di dialogo Impostazioni compilatore avanzato.

  4. Nell'elenco Framework di destinazione (tutte le configurazioni) selezionare .NET Framework 4. Non selezionare Profilo client .NET Framework 4.

  5. Fare clic su OK.

    Viene visualizzata la finestra di dialogo Modifica del framework di destinazione.

  6. Nella finestra di dialogo Modifica framework di destinazione fare clic su Sì.

    Il progetto viene chiuso e quindi riaperto.

  7. Aggiungere un riferimento all'assembly di memorizzazione nella cache seguendo questa procedura:

    1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto e quindi scegliere Aggiungi riferimento.

    2. Selezionare la scheda .NET , selezionare System.Runtime.Cachinge quindi fare clic su OK.

Per modificare .NET Framework di destinazione in un progetto Visual C#

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto e quindi scegliere Proprietà.

    Viene visualizzata la finestra delle proprietà per l'applicazione.

  2. Fare clic sulla scheda Applicazione .

  3. Nell'elenco Framework di destinazione selezionare .NET Framework 4. Non selezionare Profilo client .NET Framework 4.

  4. Aggiungere un riferimento all'assembly di memorizzazione nella cache seguendo questa procedura:

    1. Fare clic con il pulsante destro del mouse sulla cartella Riferimenti e quindi scegliere Aggiungi riferimento.

    2. Selezionare la scheda .NET , selezionare System.Runtime.Cachinge quindi fare clic su OK.

Aggiunta di un pulsante alla finestra WPF

Successivamente, si aggiungerà un controllo pulsante e si creerà un gestore eventi per l'evento del Click pulsante. Successivamente si aggiungerà il codice a in modo che quando si fa clic sul pulsante, il contenuto del file di testo viene memorizzato nella cache e visualizzato.

Per aggiungere un controllo pulsante

  1. In Esplora soluzioni fare doppio clic sul file MainWindow.xaml per aprirlo.

  2. Dalla casella degli strumenti, in Controlli WPF comuni trascinare un Button controllo nella MainWindow finestra.

  3. Nella finestra Proprietà impostare la Content proprietà del Button controllo su Recupera cache.

Inizializzazione della cache e memorizzazione nella cache di una voce

Successivamente, si aggiungerà il codice per eseguire le attività seguenti:

  • Creare un'istanza della classe cache, ovvero creare un'istanza di un nuovo MemoryCache oggetto.

  • Specificare che la cache usa un HostFileChangeMonitor oggetto per monitorare le modifiche nel file di testo.

  • Leggere il file di testo e memorizzarne nella cache il contenuto come voce della cache.

  • Visualizzare il contenuto del file di testo memorizzato nella cache.

Per creare l'oggetto cache

  1. Fai doppio clic sul pulsante appena aggiunto per creare un gestore eventi nel file MainWindow.xaml.cs o MainWindow.Xaml.vb.

  2. Nella parte superiore del file (prima della dichiarazione di classe) aggiungere le istruzioni seguenti Imports (Visual Basic) o using (C#):

    using System.Runtime.Caching;
using System.IO;

    Imports System.Runtime.Caching
Imports System.IO

  3. Nel gestore eventi aggiungere il codice seguente per creare un'istanza dell'oggetto cache:

    ObjectCache cache = MemoryCache.Default;

    Dim cache As ObjectCache = MemoryCache.Default

    La ObjectCache classe è una classe predefinita che fornisce una cache di oggetti in memoria.

  4. Aggiungere il codice seguente per leggere il contenuto di una voce della cache denominata filecontents:

    Dim fileContents As String = TryCast(cache("filecontents"), String)

    string fileContents = cache["filecontents"] as string;

  5. Aggiungere il codice seguente per verificare se la voce della cache denominata filecontents esiste:

    If fileContents Is Nothing Then

End If

    if (fileContents == null)
{

}

    Se la voce di cache specificata non esiste, è necessario leggere il file di testo e aggiungerlo come voce della cache alla cache.

  6. if/then Nel blocco aggiungere il codice seguente per creare un nuovo CacheItemPolicy oggetto che specifica che la voce della cache scade dopo 10 secondi.

    Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)

    CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);

    Se non vengono fornite informazioni di rimozione o scadenza, il valore predefinito è InfiniteAbsoluteExpiration, ovvero le voci della cache non scadono mai in base a un tempo assoluto. Al contrario, le voci della cache scadono solo quando si verifica un utilizzo elevato di memoria. Come procedura consigliata, è consigliabile fornire sempre in modo esplicito una scadenza assoluta o variabile.

  7. All'interno del if/then blocco e seguendo il codice aggiunto nel passaggio precedente, aggiungere il codice seguente per creare una raccolta per i percorsi di file da monitorare e aggiungere il percorso del file di testo alla raccolta:

    Dim filePaths As New List(Of String)()
filePaths.Add("c:\cache\cacheText.txt")

    List<string> filePaths = new List<string>();
filePaths.Add("c:\\cache\\cacheText.txt");

    Nota

    Se il file di testo che si vuole usare non c:\cache\cacheText.txtè , specificare il percorso in cui si vuole usare il file di testo.

  8. Dopo il codice aggiunto nel passaggio precedente, aggiungere il codice seguente per aggiungere un nuovo HostFileChangeMonitor oggetto alla raccolta di monitoraggi delle modifiche per la voce della cache:

    policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))

    policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));

    L'oggetto HostFileChangeMonitor monitora il percorso del file di testo e invia una notifica alla cache se si verificano modifiche. In questo esempio la voce della cache scadrà se il contenuto del file cambia.

  9. Dopo il codice aggiunto nel passaggio precedente, aggiungere il codice seguente per leggere il contenuto del file di testo:

    fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()

    fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;

    Il timestamp di data e ora viene aggiunto in modo da poter vedere quando scade la voce della cache.

  10. Dopo il codice aggiunto nel passaggio precedente, aggiungere il codice seguente per inserire il contenuto del file nell'oggetto cache come CacheItem istanza:

    cache.Set("filecontents", fileContents, policy)

    cache.Set("filecontents", fileContents, policy);

    Specificare informazioni sulla modalità di rimozione della voce della cache passando l'oggetto CacheItemPolicy creato in precedenza come parametro.

  11. Dopo il if/then blocco, aggiungere il codice seguente per visualizzare il contenuto del file memorizzato nella cache in una finestra di messaggio:

    MessageBox.Show(fileContents)

    MessageBox.Show(fileContents);

  12. Nel menu Compila fare clic su Compila WPFCaching per compilare il progetto.

Test della memorizzazione nella cache nell'applicazione WPF

È ora possibile testare l'applicazione.

Per testare la memorizzazione nella cache nell'applicazione WPF

  1. Premere CTRL+F5 per eseguire l'applicazione.

    Viene visualizzata la MainWindow finestra.

  2. Fare clic su Recupera cache.

    Il contenuto memorizzato nella cache dal file di testo viene visualizzato in una finestra di messaggio. Si noti il timestamp nel file.

  3. Chiudere la finestra di messaggio e quindi fare di nuovo clic su Recupera cache .

    Il timestamp è invariato. Indica che il contenuto memorizzato nella cache viene visualizzato.

  4. Attendere 10 secondi o più e quindi fare di nuovo clic su Recupera cache .

    Questa volta viene visualizzato un nuovo timestamp. Ciò indica che i criteri consentono la scadenza della voce della cache e che viene visualizzato il nuovo contenuto memorizzato nella cache.

  5. In un editor di testo aprire il file di testo creato. Non apportare ancora modifiche.

  6. Chiudere la finestra di messaggio e quindi fare di nuovo clic su Recupera cache .

    Si noti di nuovo il timestamp.

  7. Apportare una modifica al file di testo e quindi salvare il file.

  8. Chiudere la finestra di messaggio e quindi fare di nuovo clic su Recupera cache .

    Questa finestra di messaggio contiene il contenuto aggiornato dal file di testo e un nuovo timestamp. Ciò indica che il monitoraggio modifiche del file host ha rimosso immediatamente la voce della cache quando è stato modificato il file, anche se il periodo di timeout assoluto non era scaduto.

    Nota

    È possibile aumentare il tempo di rimozione a 20 secondi o più per consentire più tempo per apportare una modifica nel file.

Esempio di codice

Dopo aver completato questa procedura dettagliata, il codice per il progetto creato sarà simile all'esempio seguente.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Runtime.Caching;
using System.IO;

namespace WPFCaching
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {

            ObjectCache cache = MemoryCache.Default;
            string fileContents = cache["filecontents"] as string;

            if (fileContents == null)
            {
                CacheItemPolicy policy = new CacheItemPolicy();
                policy.AbsoluteExpiration =
                    DateTimeOffset.Now.AddSeconds(10.0);

                List<string> filePaths = new List<string>();
                filePaths.Add("c:\\cache\\cacheText.txt");

                policy.ChangeMonitors.Add(new
                    HostFileChangeMonitor(filePaths));

                // Fetch the file contents.
                fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now.ToString();

                cache.Set("filecontents", fileContents, policy);
            }
            MessageBox.Show(fileContents);
        }
    }
}

Imports System.Runtime.Caching
Imports System.IO

Class MainWindow

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles Button1.Click
        Dim cache As ObjectCache = MemoryCache.Default
        Dim fileContents As String = TryCast(cache("filecontents"), _
            String)

        If fileContents Is Nothing Then
            Dim policy As New CacheItemPolicy()
            policy.AbsoluteExpiration = _
                DateTimeOffset.Now.AddSeconds(10.0)
            Dim filePaths As New List(Of String)()
            filePaths.Add("c:\cache\cacheText.txt")
            policy.ChangeMonitors.Add(New  _
                HostFileChangeMonitor(filePaths))

            ' Fetch the file contents.
            fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
            cache.Set("filecontents", fileContents, policy)
        End If
        MessageBox.Show(fileContents)
    End Sub
End Class

Vedi anche