Exemplarische Vorgehensweise: Zwischenspeichern von Anwendungsdaten in einer WPF-Anwendung

Artikel
01/30/2025

Mit der Zwischenspeicherung können Sie Daten im Arbeitsspeicher speichern, um schnell darauf zugreifen zu können. Wenn erneut auf die Daten zugegriffen wird, können Anwendungen die Daten aus dem Cache abrufen, anstatt sie aus der ursprünglichen Quelle abzurufen. Dies kann die Leistung und Skalierbarkeit verbessern. Darüber hinaus stellt das Zwischenspeichern Daten zur Verfügung, wenn die Datenquelle vorübergehend nicht verfügbar ist.

.NET Framework stellt Klassen bereit, mit denen Sie Zwischenspeichern in .NET Framework-Anwendungen verwenden können. Diese Klassen befinden sich im System.Runtime.Caching-Namespace.

Anmerkung

Der System.Runtime.Caching Namespace ist neu in .NET Framework 4. 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 von ASP.NET Klassen.

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie die Zwischenspeicherungsfunktionalität verwenden, die im .NET Framework als Teil einer Windows Presentation Foundation (WPF)-Anwendung verfügbar ist. In der Anleitung 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 .NET Framework 4.
Initialisieren eines Caches.
Hinzufügen eines Cacheeintrags, der den Inhalt einer Textdatei enthält.
Bereitstellen einer Entfernungrichtlinie für den Cacheeintrag.
Überwachen des Pfads der zwischengespeicherten Datei und Benachrichtigen der Cacheinstanz über Änderungen am überwachten Element.

Voraussetzungen

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

Visual Studio 2010.
Eine Textdatei, die eine kleine Textmenge 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 in dieser exemplarischen Vorgehensweise kleine Änderungen am Code vornehmen.

Erstellen eines WPF-Anwendungsprojekts

Zunächst erstellen Sie ein WPF-Anwendungsprojekt.

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 Vorlagendie Programmiersprache aus, die Sie verwenden möchten (Visual Basic oder Visual C#).
Wählen Sie im Dialogfeld Neues Projekt die Option WPF-Anwendung aus.

Anmerkung

Wenn die Vorlage WPF Application nicht angezeigt wird, stellen Sie sicher, dass Sie auf eine Version des .NET Framework zielen, die WPF unterstützt. Wählen Sie im Dialogfeld Neues Projekt .NET Framework 4 aus der Liste aus.
Geben Sie im Textfeld Name einen Namen für Ihr 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 My Project, die Datei "Application.xaml" und die Datei "MainWindow.xaml".

Ausrichten auf das .NET Framework und Hinzufügen eines Verweises zu den Zwischenspeicherassemblys

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 .NET Framework 4 (nicht auf .NET Framework 4 Client Profile) abzielen und einen Verweis auf den Namespace enthalten.

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

Anmerkung

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 .NET Framework-Ziel in Visual Basic

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 Kompilieren.
Klicken Sie unten im Fenster auf Erweiterte Kompilierungsoptionen....

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 Änderung des Zielframeworks auf Ja.

Das Projekt wird geschlossen und anschließend 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 System.Runtime.Caching aus, und klicken Sie dann auf OK.

So ändern Sie das .NET Framework-Ziel 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 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ächen-Steuerelement hinzu und erstellen einen Ereignishandler für das Click-Ereignis der Schaltfläche. Später fügen Sie Code hinzu. Wenn Sie auf die Schaltfläche klicken, werden die Inhalte der Textdatei zwischengespeichert und angezeigt.

So fügen Sie ein Schaltflächen-Steuerelement 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 die Content-Eigenschaft des Button-Steuerelements im Fenster Eigenschaften auf Cache abrufen fest.

Cache initialisieren und einen Eintrag zwischenspeichern

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

Erstellen Sie eine Instanz der Cacheklasse, d. h., 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 speichern Sie deren Inhalt als Cache-Eintrag.
Zeigt den Inhalt der zwischengespeicherten Textdatei an.

So erstellen Sie das Cacheobjekt

Doppelklicken Sie auf die Schaltfläche, die Sie soeben 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 zu instanziieren:
```
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 namens filecontentszu lesen:

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 Arbeitsspeicherdruck besteht. Als bewährte Methode sollten Sie immer explizit entweder ein absolutes oder ein gleitendes Ablaufdatum angeben.
Fügen Sie im if/then-Block und nach dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um eine Collection für die zu überwachenden Dateipfade zu erstellen und den Pfad der Textdatei zur Collection 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");
```
Anmerkung

Wenn die zu verwendende Textdatei nicht c:\cache\cacheText.txtist, geben Sie den Pfad an, in dem die Textdatei verwendet werden soll.
Fügen Sie nach dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um der Collection 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 vorgenommen werden. In diesem Beispiel läuft der Cacheeintrag ab, wenn sich der Inhalt der Datei ändert.
Fügen Sie nach 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 Zeitstempel für Datum und Uhrzeit wird hinzugefügt, sodass Sie sehen können, wann der Cacheeintrag abläuft.
Fügen Sie nach dem Code, den Sie im vorherigen Schritt hinzugefügt haben, den folgenden Code hinzu, um den Inhalt der Datei als eine CacheItem-Instanz in das Cache-Objekt einzufügen.
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Sie geben Informationen dazu an, wie der Cacheeintrag gelöscht werden soll, indem Sie das zuvor als Parameter erstellte CacheItemPolicy-Objekt übergeben.
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 WPFCaching kompilieren, um Ihr Projekt zu kompilieren.

Testen der Zwischenspeicherung in der WPF-Anwendung

Sie können die Anwendung jetzt testen.

Um das Caching in der WPF-Anwendung zu testen

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 der Datei.
Schließen Sie das Nachrichtenfeld, und klicken Sie dann erneut auf Cache abrufen.

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

Diesmal 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 Nachrichtenfeld, und klicken Sie dann erneut auf Cache abrufen.

Beachten Sie den Zeitstempel erneut.
Nehmen Sie eine Änderung an der Textdatei vor, und speichern Sie die Datei.
Schließen Sie das Nachrichtenfeld, und klicken Sie dann erneut auf Cache abrufen.

Dieses Meldungsfeld enthält den aktualisierten Inhalt aus der Textdatei und einen neuen Zeitstempel. Dies weist darauf hin, dass der Hostdateiänderungsmonitor den Cacheeintrag sofort beim Ändern der Datei entfernt hat, obwohl der absolute Timeoutzeitraum nicht abgelaufen war.

Anmerkung

Sie können die Räumungszeit auf 20 Sekunden oder mehr erhöhen, um Ihnen mehr Zeit zu geben, eine Änderung in der Datei vorzunehmen.

Codebeispiel

Nachdem Sie diese Anleitung abgeschlossen haben, ähnelt der Code für Ihr erstelltes 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

Freigeben über