Overzicht: Toepassingsgegevens in cache opslaan in een WPF-toepassing

Artikel
12/18/2024

Met caching kunt u gegevens opslaan in het geheugen voor snelle toegang. Wanneer de gegevens opnieuw worden geopend, kunnen toepassingen de gegevens ophalen uit de cache in plaats van deze op te halen uit de oorspronkelijke bron. Dit kan de prestaties en schaalbaarheid verbeteren. Bovendien maakt caching gegevens beschikbaar wanneer de gegevensbron tijdelijk niet beschikbaar is.

.NET Framework biedt klassen waarmee u caching kunt gebruiken in .NET Framework-toepassingen. Deze klassen bevinden zich in de System.Runtime.Caching naamruimte.

Notitie

De System.Runtime.Caching naamruimte is nieuw in .NET Framework 4. Deze naamruimte maakt caching beschikbaar voor alle .NET Framework-toepassingen. In eerdere versies van .NET Framework was caching alleen beschikbaar in de System.Web naamruimte en vereist daarom een afhankelijkheid van ASP.NET klassen.

In dit overzicht ziet u hoe u de cachefunctionaliteit gebruikt die beschikbaar is in .NET Framework als onderdeel van een WPF-toepassing (Windows Presentation Foundation). In het overzicht slaat u de inhoud van een tekstbestand in de cache op.

Taken die in deze doorloop worden geïllustreerd, zijn onder andere:

Een WPF-toepassingsproject maken.
Een verwijzing toevoegen naar .NET Framework 4.
Initialiseren van een cache.
Een cachevermelding toevoegen die de inhoud van een tekstbestand bevat.
Het verstrekken van een verwijderingsbeleid voor de cachevermelding.
Controleer het pad van het in de cache opgeslagen bestand en informeer het cache-exemplaar over wijzigingen in het bewaakte item.

Voorwaarden

Als u deze procedure wilt voltooien, hebt u het volgende nodig:

Visual Studio 2010.
Een tekstbestand met een kleine hoeveelheid tekst. (U geeft de inhoud van het tekstbestand weer in een berichtvak.) In de code die in het scenario wordt geïllustreerd, wordt ervan uitgegaan dat u met het volgende bestand werkt:

c:\cache\cacheText.txt

U kunt echter elk tekstbestand gebruiken en kleine wijzigingen aanbrengen in de code in dit scenario.

Een WPF-toepassingsproject maken

U begint met het maken van een WPF-toepassingsproject.

Een WPF-toepassing maken

Start Visual Studio.
Klik in het menu Bestand op Nieuwen klik vervolgens op Nieuw project.

Het dialoogvenster Nieuw project wordt weergegeven.
Selecteer onder Geïnstalleerde sjablonende programmeertaal die u wilt gebruiken (Visual Basic of Visual C#).
Selecteer in het Nieuw project-dialoogvenster de optie WPF-toepassing.

Notitie

Als u de sjabloon WPF-toepassing niet ziet, controleert u of u zich richt op een versie van .NET Framework die WPF ondersteunt. Selecteer in het dialoogvenster Nieuw project .NET Framework 4 in de lijst.
Voer in het tekstvak Naam een naam in voor uw project. U kunt bijvoorbeeld WPFCaching-invoeren.
Schakel het selectievakje Map maken voor oplossing in.
Klik op OK-.

De WPF Designer wordt geopend in ontwerpweergave en geeft het bestand MainWindow.xaml weer. Visual Studio maakt de map My Project, het bestand Application.xaml en het bestand MainWindow.xaml.

Het .NET Framework targeten en een verwijzing toevoegen aan de cache-assemblages.

WPF-toepassingen zijn standaard gericht op het .NET Framework 4-clientprofiel. Als u de System.Runtime.Caching-naamruimte in een WPF-toepassing wilt gebruiken, moet de toepassing zich richten op .NET Framework 4 (niet op het .NET Framework 4-clientprofiel) en moet deze een verwijzing naar de naamruimte bevatten.

Daarom is de volgende stap het wijzigen van het .NET Framework-doel en het toevoegen van een verwijzing naar de System.Runtime.Caching-naamruimte.

Notitie

De procedure voor het wijzigen van het .NET Framework-doel verschilt in een Visual Basic-project en in een Visual C#-project.

Om het doel van de .NET Framework in Visual Basic te wijzigen

Klik in Solutions Explorermet de rechtermuisknop op de projectnaam en klik vervolgens op Eigenschappen.

Het eigenschappenvenster voor de toepassing wordt weergegeven.
Klik op het tabblad Compileren.
Klik onder aan het venster op Geavanceerde Compileeropties....

Het dialoogvenster Geavanceerde compilerinstellingen wordt weergegeven.
Selecteer in de doelframework (alle configuraties) lijst .NET Framework 4. Kies het .NET Framework 4 Client Profiel niet.
Klik op OK-.

Het dialoogvenster Doelframework-wijziging wordt weergegeven.
Klik in het dialoogvenster Doelframework wijzigen op Ja.

Het project is gesloten en wordt vervolgens opnieuw geopend.
Voeg een verwijzing toe naar de cache-assembly door de volgende stappen uit te voeren:
1. Klik in Solution Explorermet de rechtermuisknop op de naam van het project en klik vervolgens op Verwijzing toevoegen.
2. Selecteer het tabblad .NET, selecteer System.Runtime.Cachingen klik vervolgens op OK.

Wijzigen van het doel .NET Framework in een Visual C#-project

Klik in Solution Explorermet de rechtermuisknop op de projectnaam en klik vervolgens op Eigenschappen.

Het eigenschappenvenster voor de toepassing wordt weergegeven.
Klik op het tabblad Toepassing.
Selecteer .NET Framework 4 in de lijst Target Framework. (Selecteer niet .NET Framework 4-clientprofiel.)
Voeg een verwijzing toe naar de cache-assembly door de volgende stappen uit te voeren:
1. Klik met de rechtermuisknop op de map Verwijzingen en klik vervolgens op Verwijzing toevoegen.
2. Selecteer het tabblad .NET, selecteer System.Runtime.Cachingen klik vervolgens op OK.

Een knop toevoegen aan het WPF-venster

Vervolgens voegt u een knopcontrole toe en maakt u een eventhandler voor de Click-gebeurtenis van de knop. Later voegt u code toe, zodat wanneer u op de knop klikt, de inhoud van het tekstbestand in de cache wordt opgeslagen en weergegeven.

Een knopbedieningselement toevoegen

Dubbelklik in Solution Explorerop het bestand MainWindow.xaml om het te openen.
Sleep een Button controle uit de Toolboxonder Common WPF Controlsin het MainWindow venster.
Stel in het venster Eigenschappen de eigenschap Content van de controle Button in op Ophalen van de cache.

De cache initialiseren en een vermelding in de cache opslaan

Vervolgens voegt u de code toe om de volgende taken uit te voeren:

Maak een instantie van de cacheklasse, oftewel u maakt een nieuw MemoryCache-object aan.
Geef op dat de cache een HostFileChangeMonitor-object gebruikt om wijzigingen in het tekstbestand te controleren.
Lees het tekstbestand en sla de inhoud ervan op als cachevermelding.
De inhoud van het tekstbestand in de cache weergeven.

Het cacheobject maken

Dubbelklik op de knop die u zojuist hebt toegevoegd om een gebeurtenis-handler te maken in de MainWindow.xaml.cs of MainWindow.Xaml.vb bestand.
Voeg boven aan het bestand (vóór de klassedeclaratie) de volgende Imports (Visual Basic) of using (C#) toe:
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
Voeg in de gebeurtenis-handler de volgende code toe om het cacheobject te instantiëren:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
De ObjectCache-klasse is een ingebouwde klasse die een in-memory objectcache biedt.

Voeg de volgende code toe om de inhoud van een cachevermelding met de naam filecontentste lezen:

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

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

Voeg de volgende code toe om te controleren of de cachevermelding met de naam filecontents bestaat:
```
If fileContents Is Nothing Then

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

}
```
Als de opgegeven cachevermelding niet bestaat, moet u het tekstbestand lezen en toevoegen als cachevermelding aan de cache.
Voeg in het if/then blok de volgende code toe om een nieuw CacheItemPolicy-object te maken dat aangeeft dat de cachevermelding na 10 seconden verloopt.
```
Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
```
```
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
```
Als er geen verwijderings- of verloopgegevens worden opgegeven, wordt de standaardwaarde InfiniteAbsoluteExpiration, wat betekent dat de cachevermeldingen nooit verlopen op basis van een absolute tijd. In plaats daarvan verlopen cachevermeldingen alleen wanneer er geheugendruk is. Als best practice moet u altijd expliciet een absolute of een glijdende vervaldatum opgeven.
Voeg in het if/then-blok en na de code die u in de vorige stap hebt toegevoegd, de volgende code toe om een collectie te maken voor de bestandspaden die u wilt bewaken en om het pad van het tekstbestand aan de collectie toe te voegen.
```
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");
```
Notitie

Als het tekstbestand dat u wilt gebruiken niet is c:\cache\cacheText.txt, geeft u het pad op waar het tekstbestand is dat u wilt gebruiken.
Voeg na de code die u in de vorige stap hebt toegevoegd, de volgende code toe om een nieuw HostFileChangeMonitor-object toe te voegen aan de verzameling wijzigingsmonitors voor de cachevermelding:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
Het HostFileChangeMonitor object bewaakt het pad van het tekstbestand en geeft een bericht over de cache als er wijzigingen optreden. In dit voorbeeld verloopt de cachevermelding als de inhoud van het bestand wordt gewijzigd.
Voeg na de code die u in de vorige stap hebt toegevoegd, de volgende code toe om de inhoud van het tekstbestand te lezen:
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
De datum- en tijdstempel wordt toegevoegd, zodat u kunt zien wanneer de cachevermelding verloopt.
Voeg na de code die u in de vorige stap hebt toegevoegd, de volgende code toe om de inhoud van het bestand in te voegen in het cacheobject als een CacheItem exemplaar:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
U geeft informatie op over hoe de cachevermelding moet worden verwijderd door het CacheItemPolicy-object door te geven dat u eerder hebt gemaakt als parameter.
Voeg na het if/then blok de volgende code toe om de inhoud van het bestand in de cache weer te geven in een berichtvak:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
Klik in het menu Build op Build WPFCaching- om uw project te bouwen.

Het testen van caching in de WPF-toepassing

U kunt de toepassing nu testen.

Om het cachen in de WPF-toepassing te testen

Druk op Ctrl+F5 om de toepassing uit te voeren.

Het venster MainWindow wordt weergegeven.
Klik op Cache ophalen.

De inhoud in de cache van het tekstbestand wordt weergegeven in een berichtvak. Let op de tijdstempel van het bestand.
Sluit het berichtvak en klik vervolgens nogmaals op Cache ophalen.

De tijdstempel is ongewijzigd. Dit geeft aan dat de inhoud in de cache wordt weergegeven.
Wacht 10 seconden of meer en klik vervolgens nogmaals op Cache ophalen.

Deze keer wordt een nieuwe tijdstempel weergegeven. Dit geeft aan dat het beleid de cachevermelding laat verlopen en dat nieuwe inhoud in de cache wordt weergegeven.
Open in een teksteditor het tekstbestand dat u hebt gemaakt. Breng nog geen wijzigingen aan.
Sluit het berichtvak en klik vervolgens opnieuw op Cache ophalen.

Let nogmaals op de tijdstempel.
Breng een wijziging aan in het tekstbestand en sla het bestand op.
Sluit het berichtvak en klik vervolgens nogmaals op Ophalen Cache.

Dit berichtvak bevat de bijgewerkte inhoud uit het tekstbestand en een nieuwe tijdstempel. Dit geeft aan dat de monitor voor het wijzigen van het hostbestand de cachevermelding onmiddellijk heeft verwijderd toen u het bestand wijzigde, ook al was de absolute time-outperiode niet verlopen.

Notitie

U kunt de verwijderingstijd verhogen naar 20 seconden of meer, zodat u meer tijd hebt om een wijziging in het bestand aan te brengen.

Codevoorbeeld

Nadat u dit scenario hebt voltooid, lijkt de code voor het project dat u hebt gemaakt op het volgende voorbeeld.

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

Delen via