Procédure pas à pas : mise en cache des données d’application dans une application WPF

Article
06/02/2023

La mise en cache vous permet de stocker des données en mémoire pour y accéder rapidement. Quand vous accédez à nouveau aux données, les applications peuvent obtenir les données à partir du cache au lieu de devoir les récupérer à partir de la source d’origine. Cela peut améliorer les performances et la scalabilité. La mise en cache rend également les données disponibles quand la source de données est temporairement indisponible.

Le .NET Framework fournit des classes qui vous permettent d’utiliser la mise en cache dans les applications .NET Framework. Ces classes se trouvent dans l’espace System.Runtime.Caching de noms.

Remarque

L’espace System.Runtime.Caching de noms est nouveau dans .NET Framework 4. Cet espace de noms rend la mise en cache disponible pour toutes les applications .NET Framework. Dans les versions précédentes du .NET Framework, la mise en cache était disponible seulement dans l’espace de noms System.Web et nécessitait donc une dépendance vis-à-vis de classes ASP.NET.

Cette procédure pas à pas vous montre comment utiliser la fonctionnalité de mise en cache disponible dans le .NET Framework dans le cadre d’une application WPF (Windows Presentation Foundation). Dans la procédure pas à pas, vous devez mettre en cache le contenu d’un fichier texte.

Cette procédure pas à pas décrit les tâches suivantes :

Création d’un projet d’application WPF.
Ajout d’une référence au .NET Framework 4.
Initialisation d’un cache.
Ajout d’une entrée de cache qui contient le contenu d’un fichier texte.
Fourniture d’une stratégie d’éviction pour l’entrée du cache.
Surveillance du chemin d’accès du fichier mis en cache et notification de l’instance de cache sur les modifications apportées à l’élément surveillé.

Prérequis

Pour réaliser cette procédure pas à pas, vous aurez besoin des éléments suivants :

Visual Studio 2010.
Fichier texte qui contient une petite quantité de texte. (Vous affichez le contenu du fichier texte dans une zone de message.) Le code illustré dans la procédure pas à pas suppose que vous utilisez le fichier suivant :

c:\cache\cacheText.txt

Toutefois, vous pouvez utiliser n’importe quel fichier texte et apporter de petites modifications au code dans cette procédure pas à pas.

Création d’un projet d’application WPF

Vous commencerez par créer un projet d’application WPF.

Pour créer une application WPF

Démarrez Visual Studio.
Dans le menu Fichier , cliquez sur Nouveau, puis sur Nouveau projet.

La boîte de dialogue Nouveau projet s’affiche.
Sous Modèles installés, sélectionnez le langage de programmation que vous souhaitez utiliser (Visual Basic ou Visual C#).
Dans la boîte de dialogue Nouveau projet , sélectionnez Application WPF.

Remarque

Si vous ne voyez pas le modèle d’application WPF, vérifiez que vous ciblez une version du .NET Framework qui prend en charge WPF. Dans la boîte de dialogue Nouveau projet , sélectionnez .NET Framework 4 dans la liste.
Dans la zone de texte Nom , entrez un nom pour votre projet. Par exemple, vous pouvez entrer WPFCaching.
Cochez la case Créer le répertoire pour la solution.
Cliquez sur OK.

Le Concepteur WPF s’ouvre en mode Création et affiche le fichier MainWindow.xaml. Visual Studio crée le dossier My Project , le fichier Application.xaml et le fichier MainWindow.xaml.

Ciblage du .NET Framework et ajout d’une référence aux assemblys de mise en cache

Par défaut, les applications WPF ciblent le profil client .NET Framework 4. Pour utiliser l’espace System.Runtime.Caching de noms dans une application WPF, l’application doit cibler le .NET Framework 4 (et non le profil client .NET Framework 4) et doit inclure une référence à l’espace de noms.

Par conséquent, l’étape suivante consiste à modifier la cible .NET Framework et à ajouter une référence à l’espace System.Runtime.Caching de noms.

Remarque

La procédure de modification de la cible .NET Framework est différente dans un projet Visual Basic et dans un projet Visual C#.

Pour modifier le .NET Framework cible en Visual Basic

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, puis cliquez sur Propriétés.

La fenêtre propriétés de l’application s’affiche.
Cliquez sur l’onglet Compiler.
En bas de la fenêtre, cliquez sur Options de compilation avancées....

La boîte de dialogue Paramètres du compilateur avancé s’affiche.
Dans la liste Framework cible (toutes les configurations), sélectionnez .NET Framework 4. (Ne sélectionnez pas le profil client .NET Framework 4.)
Cliquez sur OK.

La boîte de dialogue Modification du Framework cible s’affiche.
Dans la boîte de dialogue Modification du framework cible, cliquez sur Oui.

Le projet est fermé, puis rouvert.
Ajoutez une référence à l’assembly de mise en cache en procédant comme suit :
1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, puis cliquez sur Ajouter une référence.
2. Sélectionnez l’onglet .NET , sélectionnez System.Runtime.Caching, puis cliquez sur OK.

Pour modifier le .NET Framework cible dans un projet Visual C#

Dans Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, puis cliquez sur Propriétés.

La fenêtre propriétés de l’application s’affiche.
Cliquez sur l’onglet Application .
Dans la liste du framework cible, sélectionnez .NET Framework 4. (Ne sélectionnez pas le profil client .NET Framework 4.)
Ajoutez une référence à l’assembly de mise en cache en procédant comme suit :
1. Cliquez avec le bouton droit sur le dossier Références , puis cliquez sur Ajouter une référence.
2. Sélectionnez l’onglet .NET , sélectionnez System.Runtime.Caching, puis cliquez sur OK.

Ajout d’un bouton à la fenêtre WPF

Ensuite, vous allez ajouter un contrôle de bouton et créer un gestionnaire d’événements pour l’événement du Click bouton. Plus tard, vous ajouterez du code pour cela lorsque vous cliquez sur le bouton, le contenu du fichier texte est mis en cache et affiché.

Pour ajouter un contrôle de bouton

Dans Explorateur de solutions, double-cliquez sur le fichier MainWindow.xaml pour l’ouvrir.
Dans la boîte à outils, sous Contrôles WPF courants, faites glisser un Button contrôle vers la MainWindow fenêtre.
Dans la fenêtre Propriétés , définissez la Content propriété du Button contrôle sur Get Cache.

Initialisation du cache et de la mise en cache d’une entrée

Ensuite, vous allez ajouter le code pour effectuer les tâches suivantes :

Créez une instance de la classe cache, autrement dit, vous instanciez un nouvel MemoryCache objet.
Spécifiez que le cache utilise un HostFileChangeMonitor objet pour surveiller les modifications dans le fichier texte.
Lisez le fichier texte et cachez son contenu en tant qu’entrée de cache.
Affichez le contenu du fichier texte mis en cache.

Pour créer l’objet cache

Double-cliquez sur le bouton que vous venez d’ajouter pour créer un gestionnaire d’événements dans le fichier MainWindow.xaml.cs ou MainWindow.Xaml.vb.
En haut du fichier (avant la déclaration de classe), ajoutez les instructions suivantes Imports (Visual Basic) ou using (C#) :
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
Dans le gestionnaire d’événements, ajoutez le code suivant pour instancier l’objet cache :
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
La ObjectCache classe est une classe intégrée qui fournit un cache d’objets en mémoire.

Ajoutez le code suivant pour lire le contenu d’une entrée de cache nommée filecontents:

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

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

Ajoutez le code suivant pour case activée si l’entrée de cache nommée filecontents existe :
```
If fileContents Is Nothing Then

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

}
```
Si l’entrée de cache spécifiée n’existe pas, vous devez lire le fichier texte et l’ajouter en tant qu’entrée de cache au cache.
Dans le if/then bloc, ajoutez le code suivant pour créer un CacheItemPolicy objet qui spécifie que l’entrée du cache expire après 10 secondes.
```
Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
```
```
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
```
Si aucune information d’éviction ou d’expiration n’est fournie, la valeur par défaut est InfiniteAbsoluteExpiration, ce qui signifie que les entrées du cache n’expirent jamais en fonction d’un temps absolu. Au lieu de cela, les entrées de cache expirent uniquement lorsqu’il y a une pression de mémoire. En guise de meilleure pratique, vous devez toujours fournir explicitement une expiration absolue ou glissante.
À l’intérieur du if/then bloc et en suivant le code que vous avez ajouté à l’étape précédente, ajoutez le code suivant pour créer une collection pour les chemins d’accès aux fichiers que vous souhaitez surveiller et pour ajouter le chemin du fichier texte à la collection :
```
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");
```
Remarque

Si le fichier texte que vous souhaitez utiliser n’est pas c:\cache\cacheText.txt, spécifiez le chemin d’accès où le fichier texte est celui que vous souhaitez utiliser.
Après le code que vous avez ajouté à l’étape précédente, ajoutez le code suivant pour ajouter un nouvel HostFileChangeMonitor objet à la collection de moniteurs de modifications pour l’entrée du cache :
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
L’objet HostFileChangeMonitor surveille le chemin d’accès du fichier texte et avertit le cache si des modifications se produisent. Dans cet exemple, l’entrée du cache expire si le contenu du fichier change.
Après le code que vous avez ajouté à l’étape précédente, ajoutez le code suivant pour lire le contenu du fichier texte :
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
L’horodatage de date et d’heure est ajouté afin que vous puissiez voir quand l’entrée du cache expire.
Après le code que vous avez ajouté à l’étape précédente, ajoutez le code suivant pour insérer le contenu du fichier dans l’objet cache en tant qu’instance CacheItem :
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Vous spécifiez des informations sur la façon dont l’entrée du cache doit être supprimée en passant l’objet CacheItemPolicy que vous avez créé précédemment en tant que paramètre.
Après le if/then bloc, ajoutez le code suivant pour afficher le contenu du fichier mis en cache dans une boîte de message :
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
Dans le menu Générer , cliquez sur Générer WPFCaching pour générer votre projet.

Test de la mise en cache dans l’application WPF

Vous pouvez maintenant tester l’application.

Pour tester la mise en cache dans l’application WPF

Appuyez sur Ctrl+F5 pour exécuter l’application.

La MainWindow fenêtre s’affiche.
Cliquez sur Obtenir le cache.

Le contenu mis en cache du fichier texte s’affiche dans une boîte de message. Notez l’horodatage sur le fichier.
Fermez la boîte de message, puis cliquez à nouveau sur Obtenir le cache .

L’horodatage est inchangé. Cela indique que le contenu mis en cache est affiché.
Attendez 10 secondes ou plus, puis cliquez à nouveau sur Obtenir le cache .

Cette fois qu’un nouvel horodatage est affiché. Cela indique que la stratégie permet à l’entrée du cache d’expirer et que le nouveau contenu mis en cache s’affiche.
Dans un éditeur de texte, ouvrez le fichier texte que vous avez créé. N’apportez pas encore de modifications.
Fermez la boîte de message, puis cliquez à nouveau sur Obtenir le cache .

Notez à nouveau l’horodatage.
Apportez une modification au fichier texte, puis enregistrez le fichier.
Fermez la boîte de message, puis cliquez à nouveau sur Obtenir le cache .

Cette zone de message contient le contenu mis à jour à partir du fichier texte et un nouvel horodatage. Cela indique que le moniteur de modification du fichier hôte a supprimé immédiatement l’entrée du cache lorsque vous avez modifié le fichier, même si la période d’expiration absolue n’avait pas expiré.

Remarque

Vous pouvez augmenter la durée d’éviction à 20 secondes ou plus pour vous permettre d’effectuer une modification dans le fichier.

Exemple de code

Une fois cette procédure pas à pas terminée, le code du projet que vous avez créé ressemble à l’exemple suivant.

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