Návod: Ukládání aplikačních dat do mezipaměti v aplikaci WPF

Článek
10/18/2023

Ukládání do mezipaměti umožňuje ukládat data do paměti pro rychlý přístup. Po opětovném přístupu k datům mohou aplikace získat data z mezipaměti místo toho, aby je načítá z původního zdroje. To může zlepšit výkon a škálovatelnost. Ukládání do mezipaměti navíc zpřístupňuje data, když je zdroj dat dočasně nedostupný.

Rozhraní .NET Framework poskytuje třídy, které umožňují používat ukládání do mezipaměti v aplikacích .NET Framework. Tyto třídy jsou umístěny v System.Runtime.Caching oboru názvů.

Poznámka:

Obor System.Runtime.Caching názvů je v rozhraní .NET Framework 4 nový. Tento obor názvů umožňuje ukládání do mezipaměti pro všechny aplikace rozhraní .NET Framework. V předchozích verzích rozhraní .NET Framework bylo ukládání do mezipaměti k dispozici pouze v System.Web oboru názvů, a proto vyžadovalo závislost na ASP.NET třídách.

Tento návod ukazuje, jak používat funkce ukládání do mezipaměti, které jsou k dispozici v rozhraní .NET Framework jako součást aplikace Windows Presentation Foundation (WPF). V názorném postupu ukládáte obsah textového souboru do mezipaměti.

Tento návod obsahuje následující úlohy:

Vytvoření projektu aplikace WPF
Přidání odkazu na rozhraní .NET Framework 4
Inicializace mezipaměti
Přidání položky mezipaměti, která obsahuje obsah textového souboru
Poskytnutí zásad vyřazení pro položku mezipaměti.
Sledování cesty k souboru v mezipaměti a upozorňování instance mezipaměti na změny monitorované položky.

Předpoklady

K dokončení tohoto návodu budete potřebovat:

Visual Studio 2010
Textový soubor, který obsahuje malé množství textu. (Obsah textového souboru se zobrazí v poli se zprávou.) Kód ilustrovaný v návodu předpokládá, že pracujete s následujícím souborem:

c:\cache\cacheText.txt

Můžete ale použít libovolný textový soubor a provést malé změny kódu v tomto názorném postupu.

Vytvoření projektu aplikace WPF

Začnete vytvořením projektu aplikace WPF.

Vytvoření aplikace WPF

Spusťte Visual Studio.
V nabídce Soubor klepněte na tlačítko Nový a potom klepněte na příkaz Nový projekt.

Zobrazí se dialogové okno Nový projekt .
V části Nainstalované šablony vyberte programovací jazyk, který chcete použít (Visual Basic nebo Visual C#).
V dialogovém okně Nový projekt vyberte aplikaci WPF.

Poznámka:

Pokud se šablona aplikace WPF nezobrazí, ujistěte se, že cílíte na verzi rozhraní .NET Framework, která podporuje WPF. V dialogovém okně Nový projekt vyberte ze seznamu rozhraní .NET Framework 4.
Do textového pole Název zadejte název projektu. Můžete například zadat WPF Ukládání do mezipaměti.
Zaškrtněte políčko Vytvořit adresář pro řešení.
Klikněte na OK.

Návrhář WPF se otevře v návrhovém zobrazení a zobrazí soubor MainWindow.xaml. Visual Studio vytvoří složku Můj projekt , soubor Application.xaml a soubor MainWindow.xaml.

Cílení na rozhraní .NET Framework a přidání odkazu na sestavení Ukládání do mezipaměti

Ve výchozím nastavení cílí aplikace WPF na profil klienta rozhraní .NET Framework 4. Chcete-li použít System.Runtime.Caching obor názvů v aplikaci WPF, musí aplikace cílit na rozhraní .NET Framework 4 (nikoli na profil klienta rozhraní .NET Framework 4) a musí obsahovat odkaz na obor názvů.

Dalším krokem je tedy změna cíle rozhraní .NET Framework a přidání odkazu na System.Runtime.Caching obor názvů.

Poznámka:

Postup změny cíle rozhraní .NET Framework se liší v projektu jazyka Visual Basic a v projektu Visual C#.

Změna cílového rozhraní .NET Framework v jazyce Visual Basic

V Průzkumníku řešení klikněte pravým tlačítkem myši na název projektu a potom klikněte na příkaz Vlastnosti.

Zobrazí se okno vlastností aplikace.
Klikněte na kartu Kompilace .
V dolní části okna klikněte na Upřesnit možnosti kompilace....

Zobrazí se dialogové okno Rozšířený kompilátor Nastavení.
V seznamu Cílové rozhraní (všechny konfigurace) vyberte rozhraní .NET Framework 4. (Nevybírejte profil klienta rozhraní .NET Framework 4.)
Klikněte na OK.

Zobrazí se dialogové okno Změna cílové architektury.
V dialogovém okně Změnit cílovou architekturu klepněte na tlačítko Ano.

Projekt se zavře a pak se znovu otevře.
Následujícím postupem přidejte odkaz na sestavení ukládání do mezipaměti:
1. V Průzkumník řešení klikněte pravým tlačítkem myši na název projektu a potom klikněte na přidat odkaz.
2. Vyberte kartu .NET, vyberte System.Runtime.Cachinga klepněte na tlačítko OK.

Změna cílového rozhraní .NET Framework v projektu Visual C#

V Průzkumník řešení klepněte pravým tlačítkem myši na název projektu a potom klepněte na příkaz Vlastnosti.

Zobrazí se okno vlastností aplikace.
Klikněte na kartu Aplikace .
V seznamu Cílové rozhraní vyberte rozhraní .NET Framework 4. (Nevybírejte profil klienta rozhraní .NET Framework 4.)
Následujícím postupem přidejte odkaz na sestavení ukládání do mezipaměti:
1. Klepněte pravým tlačítkem myši na složku Odkazy a potom klepněte na příkaz Přidat odkaz.
2. Vyberte kartu .NET, vyberte System.Runtime.Cachinga klepněte na tlačítko OK.

Přidání tlačítka do okna WPF

Dále přidáte ovládací prvek tlačítka a vytvoříte obslužnou rutinu události pro událost tlačítka Click . Později přidáte kód tak, že po kliknutí na tlačítko se obsah textového souboru uloží do mezipaměti a zobrazí se.

Přidání ovládacího prvku tlačítka

V Průzkumník řešení poklikáním otevřete soubor MainWindow.xaml.
Z panelu nástrojů v části Společné ovládací prvky WPF přetáhněte Button ovládací prvek do MainWindowokna.
V okně Vlastnosti nastavte Content vlastnost Button ovládacího prvku na Get Cache.

Inicializace mezipaměti a Ukládání do mezipaměti položky

Dále přidáte kód, který provede následující úlohy:

Vytvořte instanci třídy mezipaměti – to znamená, že vytvoříte instanci nového MemoryCache objektu.
Určete, že mezipaměť používá HostFileChangeMonitor objekt k monitorování změn v textovém souboru.
Přečtěte si textový soubor a uložte jeho obsah do mezipaměti jako položku mezipaměti.
Zobrazí obsah textového souboru uloženého v mezipaměti.

Vytvoření objektu mezipaměti

Poklikejte na tlačítko, které jste právě přidali, a vytvořte obslužnou rutinu události v souboru MainWindow.xaml.cs nebo MainWindow.Xaml.vb.
Na začátek souboru (před deklaraci třídy) přidejte následující Imports příkazy (Visual Basic) nebo using (C#):
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
Do obslužné rutiny události přidejte následující kód pro vytvoření instance objektu mezipaměti:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
Třída ObjectCache je integrovaná třída, která poskytuje mezipaměť objektů v paměti.

Přidejte následující kód pro čtení obsahu položky mezipaměti s názvem filecontents:

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

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

Přidejte následující kód, který zkontroluje, jestli položka mezipaměti existuje filecontents :
```
If fileContents Is Nothing Then

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

}
```
Pokud zadaná položka mezipaměti neexistuje, musíte přečíst textový soubor a přidat ji jako položku mezipaměti do mezipaměti.
if/then Do bloku přidejte následující kód pro vytvoření nového CacheItemPolicy objektu, který určuje, že platnost položky mezipaměti vyprší po 10 sekundách.
```
Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
```
```
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
```
Pokud nejsou zadané žádné informace o vyřazení nebo vypršení platnosti, výchozí hodnota znamená InfiniteAbsoluteExpiration, že položky mezipaměti nikdy nevyprší na základě absolutního času. Místo toho vyprší platnost položek mezipaměti pouze v případě, že je zatížení paměti. Osvědčeným postupem je vždy explicitně zadat absolutní nebo posuvné vypršení platnosti.
if/then Uvnitř bloku a následujícím kódu, který jste přidali v předchozím kroku, přidejte následující kód pro vytvoření kolekce pro cesty k souborům, které chcete monitorovat, a přidejte cestu k textovému souboru do kolekce:
```
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");
```
Poznámka:

Pokud textový soubor, který chcete použít, není c:\cache\cacheText.txt, zadejte cestu, kam chcete textový soubor použít.
Za kód, který jste přidali v předchozím kroku, přidejte následující kód pro přidání nového HostFileChangeMonitor objektu do kolekce monitorů změn pro položku mezipaměti:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
Objekt HostFileChangeMonitor monitoruje cestu k textovému souboru a upozorní mezipaměť, pokud dojde ke změnám. V tomto příkladu vyprší platnost položky mezipaměti, pokud se obsah souboru změní.
Za kód, který jste přidali v předchozím kroku, přidejte následující kód pro čtení obsahu textového souboru:
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
Časové razítko data a času se přidá, abyste viděli, kdy vyprší platnost položky mezipaměti.
Za kód, který jste přidali v předchozím kroku, přidejte následující kód pro vložení obsahu souboru do objektu mezipaměti jako CacheItem instance:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Zadáte informace o tom, jak má být položka mezipaměti vyřazena předáním objektu CacheItemPolicy , který jste vytvořili dříve jako parametr.
if/then Za blok přidejte následující kód, který zobrazí obsah souboru uloženého v mezipaměti v poli se zprávou:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
V nabídce Sestavení klepněte na tlačítko Sestavit WPF Ukládání do mezipaměti sestavení projektu.

Testování Ukládání do mezipaměti v aplikaci WPF

Teď můžete aplikaci otestovat.

Testování ukládání do mezipaměti v aplikaci WPF

Stiskněte klávesy CTRL+F5 a spusťte aplikaci.

Zobrazí se MainWindow okno.
Klikněte na Získat mezipaměť.

Obsah uložený v mezipaměti z textového souboru se zobrazí v poli se zprávou. Všimněte si časového razítka souboru.
Zavřete okno zprávy a znovu klikněte na Získat mezipaměť .

Časové razítko se nezmění. To znamená, že se zobrazí obsah uložený v mezipaměti.
Počkejte 10 sekund nebo déle a potom znovu klikněte na Získat mezipaměť .

Tentokrát se zobrazí nové časové razítko. To znamená, že zásada umožňuje vypršení platnosti položky mezipaměti a zobrazení nového obsahu v mezipaměti.
V textovém editoru otevřete textový soubor, který jste vytvořili. Zatím neprovádejte žádné změny.
Zavřete okno zprávy a znovu klikněte na Získat mezipaměť .

Všimněte si časového razítka znovu.
Proveďte změnu textového souboru a pak soubor uložte.
Zavřete okno zprávy a znovu klikněte na Získat mezipaměť .

Toto pole zprávy obsahuje aktualizovaný obsah z textového souboru a nové časové razítko. To znamená, že monitorování změn souboru hostitele okamžitě vyřadilo položku mezipaměti při změně souboru, i když absolutní časové období nevypršelo.

Poznámka:

Dobu vyřazení můžete zvětšit na 20 sekund nebo víc, abyste umožnili více času, než v souboru provedete změnu.

Příklad kódu

Po dokončení tohoto návodu bude kód pro projekt, který jste vytvořili, vypadat podobně jako v následujícím příkladu.

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

Sdílet prostřednictvím