Exemplarische Vorgehensweise: Zwischenspeichern von Anwendungsdaten in einer WPF-Anwendung

Artikel
05/04/2023

Das Zwischenspeichern ermöglicht es Ihnen, Daten für schnellen Zugriff im Arbeitsspeicher zu speichern. Wenn erneut auf die Daten zugegriffen wird, erhalten Anwendungen die Daten aus dem Zwischenspeicher, anstatt sie aus der Originalquelle abzurufen. Dies kann die Leistung und Skalierbarkeit verbessern. Darüber hinaus macht das Zwischenspeichern Daten verfügbar, wenn die Datenquelle vorübergehend nicht verfügbar ist.

Die .NET Framework bietet Klassen, mit denen Sie die Zwischenspeicherung in .NET Framework Anwendungen verwenden können. Diese Klassen befinden sich im System.Runtime.Caching-Namespace.

Hinweis

Der System.Runtime.Caching-Namespace ist neu in der Version 4 von .NET Framework. Dieser Namespace stellt die Zwischenspeicherung für alle .NET Framework Anwendungen zur Verfügung. In früheren Versionen von .NET Framework war die Zwischenspeicherung nur im System.Web-Namespace verfügbar, und erforderte daher eine Abhängigkeit der ASP.NET-Klassen.

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie die Zwischenspeicherfunktion verwenden, die im .NET Framework als Teil einer Windows Presentation Foundation (WPF)-Anwendung verfügbar ist. In der exemplarischen Vorgehensweise zwischenspeichern Sie den Inhalt einer Textdatei.

In dieser exemplarischen Vorgehensweise werden u. a. die folgenden Aufgaben beschrieben:

Erstellen eines WPF-Anwendungsprojekts.
Hinzufügen eines Verweises auf die .NET Framework 4.
Initialisieren eines Caches.
Hinzufügen eines Cacheeintrags, der den Inhalt einer Textdatei enthält.
Bereitstellen einer Eviction-Richtlinie für den Cacheeintrag.
Überwachen des Pfads der zwischengespeicherten Datei und benachrichtigen Sie die Cacheinstanz über Änderungen an dem überwachten Element.

Voraussetzungen

Für die Durchführung dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Visual Studio 2010.
Eine Textdatei, die eine kleine Menge an Text enthält. (Sie zeigen den Inhalt der Textdatei in einem Meldungsfeld an.) Der in der exemplarischen Vorgehensweise veranschaulichte Code geht davon aus, dass Sie mit der folgenden Datei arbeiten:

c:\cache\cacheText.txt

Sie können jedoch eine beliebige Textdatei verwenden und kleine Änderungen an dem Code in dieser exemplarischen Vorgehensweise vornehmen.

Erstellen einer WPF-Anwendung Project

Sie beginnen mit dem Erstellen eines WPF-Anwendungsprojekts.

So erstellen Sie eine WPF-Anwendung.

Starten Sie Visual Studio.
Klicken Sie im Menü Datei auf Neu und dann auf Neues Projekt.

Das Dialogfeld Neues Projekt wird angezeigt.
Wählen Sie unter installierten Vorlagen die Programmiersprache aus, die Sie verwenden möchten (Visual Basic oder Visual C#).
Wählen Sie im Dialogfeld Neues Projekt die Option WPF-Anwendung.

Hinweis

Wenn die WPF-Anwendungsvorlage nicht angezeigt wird, stellen Sie sicher, dass Sie auf eine Version der .NET Framework abzielen, die WPF unterstützt. Wählen Sie im Dialogfeld Neues Projekt .NET Framework 4 aus der Liste aus.
Geben Sie im Feld Name einen Namen für das Projekt ein. Sie können zum Beispiel WPFCaching eingeben.
Aktivieren Sie das Kontrollkästchen Verzeichnis für Projektmappe erstellen.
Klicken Sie auf OK.

Der WPF-Designer wird in der Entwurfsansicht geöffnet und zeigt die Datei "MainWindow.xaml" an. Visual Studio erstellt den Ordner Mein Projekt, die Datei "Application.xaml" und die Datei "MainWindow.xaml".

Ausrichtung auf das .NET Framework und Hinzufügen einer Referenz zu den Caching-Assemblies

Standardmäßig zielen WPF-Anwendungen auf das .NET Framework 4 Clientprofil ab. Um den System.Runtime.Caching-Namespace in einer WPF-Anwendung zu verwenden, muss die Anwendung auf die .NET Framework 4 (nicht das .NET Framework 4 Clientprofil) abzielen und einen Verweis auf den Namespace enthalten.

Der nächste Schritt besteht daher darin, das .NET Framework Ziel zu ändern und einen Verweis auf den System.Runtime.Caching-Namespace hinzuzufügen.

Hinweis

Das Verfahren zum Ändern des .NET Framework Ziels unterscheidet sich in einem Visual Basic Projekt und in einem Visual C#-Projekt.

So ändern Sie das Ziel .NET Framework in Visual Basic

Klicken Sie in im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Eigenschaften.

Das Eigenschaftenfenster für die Anwendung wird angezeigt.
Klicken Sie auf die Registerkarte Kompilieren.
Klicken Sie am unteren Rand des Fensters auf Erweiterte Kompilieroptionen....

Das Dialogfeld Erweiterte Compilereinstellungen wird angezeigt.
In der Liste Zielframework (alle Konfigurationen), wählen Sie .NET Framework 4. (Wählen Sie .NET Framework 4 Clientprofil nicht aus.)
Klicken Sie auf OK.

Das Dialogfeld Änderung des Zielframeworks wird angezeigt.
Klicken Sie im Dialogfeld Zielframework ändern auf Ja.

Das Projekt ist geschlossen und wird dann erneut geöffnet.
Fügen Sie einen Verweis auf die Zwischenspeicherassembly hinzu, indem Sie die folgenden Schritte ausführen:
1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen des -Projekts, und klicken Sie anschließend auf Neue Referenz hinzufügen.
2. Wählen Sie die Registerkarte .NET aus, wählen Sie die Option System.Runtime.Caching aus, und klicken Sie dann auf OK.

So ändern Sie das Ziel .NET Framework in einem Visual C#-Projekt

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Eigenschaften.

Das Eigenschaftenfenster für die Anwendung wird angezeigt.
Klicken Sie auf die Registerkarte Anwendung .
In der Liste Zielframework wählen Sie .NET Framework 4. (Wählen Sie .NET Framework 4 Clientprofil nicht aus.)
Fügen Sie einen Verweis auf die Zwischenspeicherassembly hinzu, indem Sie die folgenden Schritte ausführen:
1. Klicken Sie mit der rechten Maustaste auf den Ordner Verweise, und klicken Sie dann auf Verweis hinzufügen.
2. Wählen Sie die Registerkarte .NET aus, wählen Sie die Option System.Runtime.Caching aus, und klicken Sie dann auf OK.

Hinzufügen einer Schaltfläche zum WPF-Fenster

Als Nächstes fügen Sie ein Schaltflächensteuerelement hinzu und erstellen einen Ereignishandler für das Click-Ereignis der Schaltfläche. Später fügen Sie Code hinzu, damit Sie auf die Schaltfläche klicken, werden die Inhalte der Textdatei zwischengespeichert und angezeigt.

So fügen Sie eine Schaltflächen-Schaltflächen-Steuerelements hinzu

Doppelklicken Sie im Projektmappen-Explorerauf die Datei "MainWindow.xaml", um sie zu öffnen.
Ziehen Sie aus der Toolbox unter allgemeinen WPF-Steuerelementen ein Button Steuerelement in das MainWindow Fenster.
Legen Sie im Fenster Eigenschaften die Content Eigenschaft des Button Steuerelements auf Cache abrufen fest.

Initialisieren des Caches und zwischenspeichern eines Eintrags

Als Nächstes fügen Sie den Code hinzu, um die folgenden Aufgaben auszuführen:

Erstellen Sie eine Instanz der Cacheklasse – das heißt, Sie instanziieren ein neues MemoryCache-Objekt.
Geben Sie an, dass der Cache ein HostFileChangeMonitor-Objekt verwendet, um Änderungen in der Textdatei zu überwachen.
Lesen Sie die Textdatei, und zwischenspeichern Sie den Inhalt als Cacheeintrag.
Zeigen Sie den Inhalt der zwischengespeicherten Textdatei an.

So erstellen Sie das Cacheobjekt

Doppelklicken Sie auf die Schaltfläche, die Sie gerade hinzugefügt haben, um einen Ereignishandler in der Datei "MainWindow.xaml.cs" oder "MainWindow.Xaml.vb" zu erstellen.
Fügen Sie oben in der Datei (vor der Klassendeklaration) die folgenden Imports (Visual Basic) oder using (C#)-Anweisungen hinzu:
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
Fügen Sie im Ereignishandler den folgenden Code hinzu, um das Cacheobjekt instanziieren zu können:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
Die ObjectCache-Klasse ist eine integrierte Klasse, die einen Speicherobjektcache bereitstellt.

Fügen Sie den folgenden Code hinzu, um den Inhalt eines Cacheeintrags mit dem Namen filecontents:

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

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

Fügen Sie den folgenden Code hinzu, um zu überprüfen, ob der Cacheeintrag mit dem Namen filecontents vorhanden ist:
```
If fileContents Is Nothing Then

End If
```
```
if (fileContents == null)
{

}
```
Wenn der angegebene Cacheeintrag nicht vorhanden ist, müssen Sie die Textdatei lesen und als Cacheeintrag zum Cache hinzufügen.
Fügen Sie im if/then-Block den folgenden Code hinzu, um ein neues CacheItemPolicy-Objekt zu erstellen, das angibt, dass der Cacheeintrag nach 10 Sekunden abläuft.
```
Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
```
```
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
```
Wenn keine Entfernungs- oder Ablaufinformationen bereitgestellt werden, lautet der Standardwert InfiniteAbsoluteExpiration, was bedeutet, dass die Cacheeinträge niemals nach einem absoluten Zeitpunkt ablaufen. Stattdessen laufen Cacheeinträge nur ab, wenn Speicherdruck vorhanden ist. Als bewährte Methode sollten Sie entweder einen absoluten oder einen gleitenden Ablauf explizit bereitstellen.
Fügen Sie im if/then-Block und dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um eine Auflistung für die zu überwachenden Dateipfade zu erstellen und den Pfad der Textdatei zur Auflistung hinzuzufügen:
```
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");
```
Hinweis

Wenn die zu verwendende Textdatei nicht c:\cache\cacheText.txt ist, geben Sie den Pfad an, in dem die Textdatei verwendet werden soll.
Fügen Sie dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um der Auflistung von Änderungsmonitoren für den Cacheeintrag ein neues HostFileChangeMonitor-Objekt hinzuzufügen:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
Das HostFileChangeMonitor-Objekt überwacht den Pfad der Textdatei und benachrichtigt den Cache, wenn Änderungen auftreten. In diesem Beispiel läuft der Cacheeintrag ab, wenn sich der Inhalt der Datei ändert.
Fügen Sie dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um den Inhalt der Textdatei zu lesen:
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
Der Datums- und Uhrzeitstempel wird hinzugefügt, sodass Sie sehen können, wann der Cacheeintrag abläuft.
Fügen Sie dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um den Inhalt der Datei in das Cacheobjekt als CacheItem-Instanz einzufügen:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Sie geben Informationen darüber an, wie der Cacheeintrag gelöscht werden soll, indem Sie das CacheItemPolicy-Objekt übergeben, das Sie zuvor als Parameter erstellt haben.
Fügen Sie nach dem if/then-Block den folgenden Code hinzu, um den zwischengespeicherten Dateiinhalt in einem Meldungsfeld anzuzeigen:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
Klicken Sie im Menü Build auf Build WPFCaching, um Ihr Projekt zu kompilieren.

Testen der Zwischenspeicherung in der WPF-Anwendung

Die Anwendung kann nun getestet werden.

So testen Sie die Zwischenspeicherung in der WPF-Anwendung

Drücken Sie STRG+F5, um die Anwendung auszuführen.

Das MainWindow-Fenster wird angezeigt.
Klicken Sie auf Cache abrufen.

Der zwischengespeicherte Inhalt aus der Textdatei wird in einem Meldungsfeld angezeigt. Beachten Sie den Zeitstempel in der Datei.
Schließen Sie das Meldungsfeld, und klicken Sie dann erneut auf Cache abrufen.

Der Zeitstempel ist unverändert. Dies gibt an, dass der zwischengespeicherte Inhalt angezeigt wird.
Warten Sie 10 Sekunden oder mehr, und klicken Sie dann erneut auf Cache abrufen.

Dieses Mal wird ein neuer Zeitstempel angezeigt. Dies gibt an, dass die Richtlinie den Cacheeintrag ablaufen lässt und dass neue zwischengespeicherte Inhalte angezeigt werden.
Öffnen Sie in einem Text-Editor die von Ihnen erstellte Textdatei. Nehmen Sie noch keine Änderungen vor.
Schließen Sie das Meldungsfeld, und klicken Sie dann erneut auf Cache abrufen.

Beachten Sie erneut den Zeitstempel.
Ändern Sie die Textdatei, und speichern Sie dann die Datei.
Schließen Sie das Meldungsfeld, und klicken Sie dann erneut auf Cache abrufen.

Dieses Meldungsfeld enthält den aktualisierten Inhalt aus der Textdatei und einen neuen Zeitstempel. Dies gibt an, dass der Hostdateiänderungsmonitor den Cacheeintrag sofort entfernt hat, wenn Sie die Datei geändert haben, auch wenn der absolute Timeoutzeitraum nicht abgelaufen war.

Hinweis

Sie können die Zeit der Entfernung auf 20 Sekunden oder mehr erhöhen, um mehr Zeit für Sie zu ermöglichen, eine Änderung in der Datei vorzunehmen.

Codebeispiel

Nachdem Sie diese exemplarische Vorgehensweise abgeschlossen haben, ähnelt der Code für das von Ihnen erstellte Projekt dem folgenden Beispiel.

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