Wskazówki: przechowywanie w pamięci podręcznej danych aplikacji w aplikacji WPF

Buforowanie umożliwia przechowywanie danych w pamięci w celu uzyskania szybkiego dostępu. Po ponownym korzystaniu z danych aplikacje mogą pobierać dane z pamięci podręcznej zamiast pobierać je z oryginalnego źródła. Może to zwiększyć wydajność i skalowalność. Ponadto buforowanie udostępnia dane, gdy źródło danych jest tymczasowo niedostępne.

Program .NET Framework udostępnia klasy, które umożliwiają używanie buforowania w aplikacjach .NET Framework. Te klasy znajdują się w System.Runtime.Caching przestrzeni nazw.

Uwaga

System.Runtime.Caching Przestrzeń nazw jest nowa w programie .NET Framework 4. Ta przestrzeń nazw sprawia, że buforowanie jest dostępne dla wszystkich aplikacji .NET Framework. W poprzednich wersjach programu .NET Framework buforowanie było dostępne tylko w System.Web przestrzeni nazw i w związku z tym wymagało zależności od klas ASP.NET.

W tym przewodniku pokazano, jak używać funkcji buforowania, która jest dostępna w programie .NET Framework w ramach aplikacji Windows Presentation Foundation (WPF). W przewodniku buforujesz zawartość pliku tekstowego.

Zadania przedstawione w niniejszym przewodniku to m.in.:

• Tworzenie projektu aplikacji WPF.

• Dodawanie odwołania do programu .NET Framework 4.

• Inicjowanie pamięci podręcznej.

• Dodawanie wpisu pamięci podręcznej zawierającego zawartość pliku tekstowego.

• Podanie zasad eksmisji dla wpisu pamięci podręcznej.

• Monitorowanie ścieżki buforowanego pliku i powiadamianie wystąpienia pamięci podręcznej o zmianach w monitorowanym elemencie.

Wymagania wstępne

Aby ukończyć ten przewodnik, potrzebne są następujące elementy:

• Visual Studio 2010.

• Plik tekstowy zawierający niewielką ilość tekstu. (Zawartość pliku tekstowego zostanie wyświetlona w polu wiadomości). Kod przedstawiony w przewodniku zakłada, że pracujesz z następującym plikiem:

  c:\cache\cacheText.txt

  Można jednak użyć dowolnego pliku tekstowego i wprowadzić niewielkie zmiany w kodzie w tym przewodniku.

Tworzenie projektu aplikacji WPF

Rozpoczniesz od utworzenia projektu aplikacji WPF.

Aby utworzyć aplikację WPF

1. Uruchom program Visual Studio.

2. W menu Plik kliknij pozycję Nowy, a następnie kliknij pozycję Nowy projekt.

   Zostanie wyświetlone okno dialogowe Nowy projekt .

3. W obszarze Zainstalowane szablony wybierz język programowania, którego chcesz użyć (Visual Basic lub Visual C#).

4. W oknie dialogowym Nowy projekt wybierz pozycję Aplikacja WPF.

   Uwaga

   Jeśli nie widzisz szablonu aplikacji WPF, upewnij się, że jest przeznaczona wersja programu .NET Framework, która obsługuje WPF. W oknie dialogowym Nowy projekt wybierz z listy pozycję .NET Framework 4.

5. W polu tekstowym Nazwa wprowadź nazwę projektu. Możesz na przykład wprowadzić WPF Buforowanie.

6. Zaznacz pole wyboru Utwórz katalog rozwiązania.

7. Kliknij przycisk OK.

   Projektant WPF zostanie otwarty w widoku projektowym i zostanie wyświetlony plik MainWindow.xaml. Program Visual Studio tworzy folder Mój projekt , plik Application.xaml i plik MainWindow.xaml.

Określanie platformy .NET Framework i dodawanie odwołania do zestawów Buforowanie

Domyślnie aplikacje WPF są przeznaczone dla profilu klienta programu .NET Framework 4. Aby używać System.Runtime.Caching przestrzeni nazw w aplikacji WPF, aplikacja musi być skierowana do programu .NET Framework 4 (a nie profilu klienta programu .NET Framework 4) i musi zawierać odwołanie do przestrzeni nazw.

W związku z tym następnym krokiem jest zmiana docelowego programu .NET Framework i dodanie odwołania do System.Runtime.Caching przestrzeni nazw.

Uwaga

Procedura zmiany docelowego programu .NET Framework różni się w projekcie Visual Basic i w projekcie Visual C#.

Aby zmienić docelowy program .NET Framework w Visual Basic

1. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy nazwę projektu, a następnie kliknij polecenie Właściwości.

   Zostanie wyświetlone okno właściwości aplikacji.

2. Kliknij kartę Kompiluj.

3. W dolnej części okna kliknij pozycję Zaawansowane opcje kompilacji....

   Zostanie wyświetlone okno dialogowe Zaawansowane Ustawienia kompilatora.

4. Na liście Platforma docelowa (wszystkie konfiguracje) wybierz pozycję .NET Framework 4. (Nie wybieraj profilu klienta programu .NET Framework 4).

5. Kliknij przycisk OK.

   Zostanie wyświetlone okno dialogowe Zmiana struktury docelowej.

6. W oknie dialogowym Zmiana struktury docelowej kliknij przycisk Tak.

   Projekt zostanie zamknięty i zostanie ponownie otwarty.

7. Dodaj odwołanie do zestawu buforowania, wykonując następujące kroki:

   1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy nazwę projektu, a następnie kliknij polecenie Dodaj odwołanie.

   2. Wybierz kartę .NET , wybierz pozycję System.Runtime.Caching, a następnie kliknij przycisk OK.

Aby zmienić docelowy program .NET Framework w projekcie Visual C#

1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy nazwę projektu, a następnie kliknij polecenie Właściwości.

   Zostanie wyświetlone okno właściwości aplikacji.

2. Kliknij kartę Aplikacja .

3. Na liście Platforma docelowa wybierz pozycję .NET Framework 4. (Nie wybieraj profilu klienta programu .NET Framework 4).

4. Dodaj odwołanie do zestawu buforowania, wykonując następujące kroki:

   1. Kliknij prawym przyciskiem myszy folder Odwołania , a następnie kliknij polecenie Dodaj odwołanie.

   2. Wybierz kartę .NET , wybierz pozycję System.Runtime.Caching, a następnie kliknij przycisk OK.

Dodawanie przycisku do okna WPF

Następnie dodasz kontrolkę przycisku i utworzysz procedurę obsługi zdarzeń dla zdarzenia przycisku Click . Później dodasz kod, aby po kliknięciu przycisku zawartość pliku tekstowego została buforowana i wyświetlana.

Aby dodać kontrolkę przycisku

1. W Eksplorator rozwiązań kliknij dwukrotnie plik MainWindow.xaml, aby go otworzyć.

2. Z przybornika w obszarze Wspólne kontrolki WPF przeciągnij kontrolkę Button do MainWindow okna.

3. W oknie Właściwości ustaw Content właściwość kontrolki Button na Pobierz pamięć podręczną.

Inicjowanie pamięci podręcznej i Buforowanie wpisu

Następnie dodasz kod, aby wykonać następujące zadania:

• Utwórz wystąpienie klasy pamięci podręcznej — oznacza to, że utworzysz wystąpienie nowego MemoryCache obiektu.

• Określ, że pamięć podręczna HostFileChangeMonitor używa obiektu do monitorowania zmian w pliku tekstowym.

• Odczytaj plik tekstowy i buforuj jego zawartość jako wpis pamięci podręcznej.

• Wyświetl zawartość buforowanego pliku tekstowego.

Aby utworzyć obiekt pamięci podręcznej

1. Kliknij dwukrotnie dodany przycisk, aby utworzyć procedurę obsługi zdarzeń w pliku MainWindow.xaml.cs lub MainWindow.Xaml.vb.

2. W górnej części pliku (przed deklaracją klasy) dodaj następujące Imports instrukcje (Visual Basic) lub using (C#):

   using System.Runtime.Caching;
   using System.IO;
   

   Imports System.Runtime.Caching
   Imports System.IO
   

3. W procedurze obsługi zdarzeń dodaj następujący kod, aby utworzyć wystąpienie obiektu pamięci podręcznej:

   ObjectCache cache = MemoryCache.Default;
   

   Dim cache As ObjectCache = MemoryCache.Default
   

   Klasa ObjectCache jest wbudowaną klasą, która zapewnia pamięć podręczną obiektów w pamięci.

4. Dodaj następujący kod, aby odczytać zawartość wpisu pamięci podręcznej o nazwie filecontents:

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

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

5. Dodaj następujący kod, aby sprawdzić, czy wpis pamięci podręcznej o nazwie filecontents istnieje:

   If fileContents Is Nothing Then
   
   End If
   

   if (fileContents == null)
   {
   
   }
   

   Jeśli określony wpis pamięci podręcznej nie istnieje, musisz odczytać plik tekstowy i dodać go jako wpis pamięci podręcznej do pamięci podręcznej.

6. if/then W bloku dodaj następujący kod, aby utworzyć nowy CacheItemPolicy obiekt, który określa, że wpis pamięci podręcznej wygasa po 10 sekundach.

   Dim policy As New CacheItemPolicy()
   policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
   

   CacheItemPolicy policy = new CacheItemPolicy();
   policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
   

   Jeśli nie podano żadnych informacji o eksmisji lub wygaśnięciu, wartość domyślna to InfiniteAbsoluteExpiration, co oznacza, że wpisy pamięci podręcznej nigdy nie wygasają na podstawie bezwzględnego czasu. Zamiast tego wpisy pamięci podręcznej wygasają tylko wtedy, gdy występuje wykorzystanie pamięci. Najlepszym rozwiązaniem jest zawsze jawne podanie bezwzględnego lub przesuwanego wygaśnięcia.

7. if/then Wewnątrz bloku i po kodzie dodanym w poprzednim kroku dodaj następujący kod, aby utworzyć kolekcję dla ścieżek plików, które chcesz monitorować, i dodać ścieżkę pliku tekstowego do kolekcji:

   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");
   

   Uwaga

   Jeśli plik tekstowy, którego chcesz użyć, to nie c:\cache\cacheText.txt, określ ścieżkę, w której ma być używany plik tekstowy.

8. Po kodzie dodanym w poprzednim kroku dodaj następujący kod, aby dodać nowy HostFileChangeMonitor obiekt do kolekcji monitorów zmian dla wpisu pamięci podręcznej:

   policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
   

   policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
   

   Obiekt HostFileChangeMonitor monitoruje ścieżkę pliku tekstowego i powiadamia pamięć podręczną, jeśli wystąpią zmiany. W tym przykładzie wpis pamięci podręcznej wygaśnie, jeśli zawartość pliku ulegnie zmianie.

9. Po kodzie dodanym w poprzednim kroku dodaj następujący kod, aby odczytać zawartość pliku tekstowego:

   fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
   

   fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
   

   Dodawana jest sygnatura czasowa daty i godziny, dzięki czemu będzie można zobaczyć, kiedy wpis pamięci podręcznej wygaśnie.

10. Po kodzie dodanym w poprzednim kroku dodaj następujący kod, aby wstawić zawartość pliku do obiektu pamięci podręcznej jako CacheItem wystąpienie:

    cache.Set("filecontents", fileContents, policy)
    

    cache.Set("filecontents", fileContents, policy);
    

    Należy określić informacje na temat sposobu eksmitowania wpisu pamięci podręcznej przez przekazanie CacheItemPolicy obiektu utworzonego wcześniej jako parametru.

11. if/then Po bloku dodaj następujący kod, aby wyświetlić zawartość pliku w pamięci podręcznej w polu komunikatu:

    MessageBox.Show(fileContents)
    

    MessageBox.Show(fileContents);
    

12. W menu Kompilacja kliknij pozycję KompilujWPF Buforowanie aby skompilować projekt.

Testowanie Buforowanie w aplikacji WPF

Teraz możesz przetestować aplikację.

Aby przetestować buforowanie w aplikacji WPF

1. Naciśnij klawisze CTRL+F5, aby uruchomić aplikację.

   Zostanie MainWindow wyświetlone okno.

2. Kliknij pozycję Pobierz pamięć podręczną.

   Zawartość buforowana z pliku tekstowego jest wyświetlana w polu komunikatu. Zwróć uwagę na znacznik czasu w pliku.

3. Zamknij okno komunikatu, a następnie ponownie kliknij pozycję Pobierz pamięć podręczną .

   Sygnatura czasowa nie zmienia się. Oznacza to, że jest wyświetlana buforowana zawartość.

4. Poczekaj 10 sekund lub więcej, a następnie ponownie kliknij pozycję Pobierz pamięć podręczną .

   Tym razem zostanie wyświetlony nowy znacznik czasu. Oznacza to, że zasady pozwalają na wygaśnięcie wpisu pamięci podręcznej i wyświetlenie nowej buforowanej zawartości.

5. W edytorze tekstów otwórz utworzony plik tekstowy. Nie wprowadzaj jeszcze żadnych zmian.

6. Zamknij okno komunikatu, a następnie ponownie kliknij pozycję Pobierz pamięć podręczną .

   Zwróć uwagę na znacznik czasu ponownie.

7. Wprowadź zmianę w pliku tekstowym, a następnie zapisz plik.

8. Zamknij okno komunikatu, a następnie ponownie kliknij pozycję Pobierz pamięć podręczną .

   To pole komunikatu zawiera zaktualizowaną zawartość z pliku tekstowego i nowy znacznik czasu. Oznacza to, że monitor zmian pliku hosta eksmitował wpis pamięci podręcznej natychmiast po zmianie pliku, mimo że bezwzględny okres przekroczenia limitu czasu nie wygasł.

   Uwaga

   Możesz zwiększyć czas eksmisji do 20 sekund lub więcej, aby umożliwić więcej czasu na wprowadzenie zmiany w pliku.

Przykład kodu

Po ukończeniu tego przewodnika kod utworzonego projektu będzie podobny do poniższego przykładu.

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

Zobacz też

• MemoryCache
• ObjectCache
• System.Runtime.Caching
• Buforowanie w aplikacjach .NET Framework