Passo a passo: armazenar dados de aplicativo em cache em um aplicativo WPF

Artigo
06/02/2023

O cache permite que você armazene dados na memória para acesso rápido. Quando os dados são acessados novamente, os aplicativos podem obter os dados do cache, em vez de recuperá-los da fonte original. Isso pode melhorar o desempenho e a escalabilidade. Além disso, o cache torna os dados disponíveis quando a fonte de dados está temporariamente indisponível.

O .NET Framework fornece classes que permitem que você use cache em aplicativos .NET Framework. Essas classes estão localizadas no System.Runtime.Caching namespace.

Observação

O System.Runtime.Caching namespace é novo no .NET Framework 4. Esse namespace faz com que o cache esteja disponível para todos os aplicativos do .NET Framework. Nas versões anteriores do .NET Framework, o cache só estava disponível no namespace System.Web e, portanto, exigia uma dependência das classes do ASP.NET.

Este passo a passo mostra como usar a funcionalidade de cache que está disponível no .NET Framework como parte de um aplicativo Windows Presentation Foundation (WPF). No passo a passo, você armazenará em cache o conteúdo de um arquivo de texto.

As tarefas ilustradas nesta explicação passo a passo incluem o seguinte:

Criação de um projeto de aplicativo do WPF.
Adicionando uma referência ao .NET Framework 4.
Inicialização de um cache.
Adição de uma entrada de cache que contém o conteúdo de um arquivo de texto.
Fornecimento de uma política de remoção para a entrada de cache.
Monitoramento do caminho do arquivo armazenado em cache e notificação da instância de cache a respeito de alterações ao item monitorado.

Pré-requisitos

Para concluir este passo a passo, você precisará de:

Visual Studio 2010.
Um arquivo de texto que contenha uma pequena quantidade de texto. (Você exibirá o conteúdo do arquivo de texto em uma caixa de mensagem.) O código ilustrado no passo a passo pressupõe que você está trabalhando com o seguinte arquivo:

c:\cache\cacheText.txt

No entanto, você pode usar qualquer arquivo de texto e fazer pequenas alterações no código neste passo a passo.

Criação de um projeto de aplicativo do WPF

Você começará criando um projeto de aplicativo do WPF.

Criar um aplicativo WPF

Inicie o Visual Studio.
No menu Arquivo, clique em Novo e, em seguida, clique em Novo Projeto.

A caixa de diálogo Novo Projeto é exibida.
Em Modelos Instalados, selecione a linguagem de programação que você deseja usar (Visual Basic ou Visual C#).
Na caixa de diálogo Novo Projeto, selecione Aplicativo WPF.

Observação

Se você não vir o modelo de aplicativo WPF, certifique-se de que você está direcionando uma versão do .NET Framework que oferece suporte a WPF. Na caixa de diálogo Novo Projeto, selecione .NET Framework 4 na lista.
Na caixa de texto Nome, insira um nome para o projeto. Por exemplo, você pode inserir WPFCaching.
Marque a caixa de seleção Criar diretório para a solução.
Clique em OK.

O WPF Designer é aberto modo de exibição de Design e exibe o arquivo MainWindow.xaml. O Visual Studio cria a pasta My Project , o arquivo Application.xaml e o arquivo MainWindow.xaml.

Direcionamento ao .NET Framework e adição de uma referência aos assemblies de cache

Por padrão, os aplicativos WPF têm como destino o .NET Framework 4 Client Profile. Para usar o namespace em um aplicativo WPF, o aplicativo deve ter como destino o .NET Framework 4 (não o System.Runtime.Caching .NET Framework 4 Client Profile) e deve incluir uma referência ao namespace.

Portanto, a próxima etapa é alterar o destino do .NET Framework e adicionar uma referência ao System.Runtime.Caching namespace.

Observação

O procedimento para alterar o destino do .NET Framework é diferente em um projeto do Visual Basic e em um projeto Visual C#.

Para alterar o .NET Framework de destino no Visual Basic

No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e, em seguida, clique em Propriedades.

A janela Propriedades para o aplicativo é exibida.
Clique na guia Compilar.
Na parte inferior da janela, clique em Opções Avançadas de Compilação....

A caixa de diálogo Configurações Avançadas do Compilador é exibida.
Na lista Estrutura de destino (todas as configurações), selecione .NET Framework 4. (Não selecione .NET Framework 4 Client Profile).
Clique em OK.

A caixa de diálogo Alteração da Estrutura de Destino é exibida.
Na caixa de diálogo Alteração da Estrutura de Destino clique em Sim.

O projeto é fechado e, em seguida, é reaberto.
Adicione uma referência ao assembly do cache, seguindo estas etapas:
1. No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e, em seguida, clique em Adicionar Referência.
2. Selecione a guia .NET, selecione System.Runtime.Caching e, em seguida, clique em OK.

Para alterar o .NET Framework de destino em um projeto do Visual C#

No Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e, em seguida, clique em Propriedades.

A janela Propriedades para o aplicativo é exibida.
Clique na guia Aplicativo.
Na lista Estrutura de destino, selecione .NET Framework 4. (Não selecione .NET Framework 4 Client Profile).
Adicione uma referência ao assembly do cache, seguindo estas etapas:
1. Clique com o botão direito do mouse na pasta Referencias e, em seguida, clique em Adicionar Referência.
2. Selecione a guia .NET, selecione System.Runtime.Caching e, em seguida, clique em OK.

Adicionar um botão à janela do WPF

Em seguida, você adicionará um controle de botão e criará um manipulador de eventos para o evento Click do botão. Depois, você adicionará código para que quando o botão for clicado, o conteúdo do arquivo de texto será armazenado em cache e exibido.

Para adicionar um controle de botão

No Gerenciador de Soluções, clique duas vezes no arquivo MainWindow.xaml para abri-lo.
Na Caixa de ferramentas, em Controles Comuns do WPF, arraste um controle Button para a janela MainWindow.
Na janela Propriedades, defina a propriedade Content do controle Button como Obter Cache.

Inicializar o cache e armazenar uma entrada em cache

Em seguida, você adicionará o código para realizar as seguintes tarefas:

Crie uma instância da classe de cache, ou seja, você instanciará um novo MemoryCache objeto.
Especifique que o cache usa um HostFileChangeMonitor objeto para monitorar as alterações no arquivo de texto.
Ler o arquivo de texto e armazenar seu conteúdo em cache como uma entrada de cache.
Exibir o conteúdo do arquivo de texto armazenado em cache.

Para criar o objeto do cache

Clique duas vezes no botão que você acabou de adicionar para criar um manipulador de eventos no arquivo MainWindow.xaml.cs ou MainWindow.Xaml.vb.
Na parte superior do arquivo (antes da declaração de classe), adicione as seguintes instruções Imports (Visual Basic) ou using (C#):
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
No manipulador de eventos, adicione o seguinte código para instanciar o objeto de cache:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
A ObjectCache classe é uma classe interna que fornece um cache de objetos na memória.

Adicione o seguinte código para ler o conteúdo de uma entrada de cache chamada filecontents:

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

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

Adicione o seguinte código para verificar se a entrada de cache chamada filecontents existe:
```
If fileContents Is Nothing Then

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

}
```
Se a entrada de cache especificada não existe, leia o arquivo de texto e adicione-o como uma entrada de cache no cache.
if/then No bloco , adicione o código a seguir para criar um novo CacheItemPolicy objeto que especifique que a entrada de cache expira após 10 segundos.
```
Dim policy As New CacheItemPolicy()
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0)
```
```
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(10.0);
```
Se nenhuma informação de remoção ou expiração for fornecida, o padrão será InfiniteAbsoluteExpiration, o que significa que as entradas de cache nunca expiram com base apenas em um tempo absoluto. Em vez disso, as entradas de cache expiram somente quando há pressão de memória. Como prática recomendada, você deve sempre fornecer explicitamente uma expiração absoluta ou deslizante.
Dentro do bloco if/then e depois do código adicionado na etapa anterior, adicione o seguinte código para criar uma coleção para os caminhos de arquivo que você deseja monitorar e para adicionar o caminho do arquivo de texto à coleção:
```
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");
```
Observação

Se o arquivo de texto que você deseja usar não for c:\cache\cacheText.txt, especifique o caminho em que se encontra o arquivo de texto que você deseja usar.
Após o código que você adicionou na etapa anterior, adicione o seguinte código para adicionar um novo HostFileChangeMonitor objeto à coleção de monitores de alteração para a entrada de cache:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
O HostFileChangeMonitor objeto monitora o caminho do arquivo de texto e notifica o cache se ocorrerem alterações. Neste exemplo, a entrada de cache expirará se o conteúdo do arquivo for alterado.
Após o código que você adicionou na etapa anterior, adicione o seguinte código para ler o conteúdo do arquivo de texto:
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
O carimbo de data/hora é adicionado para que você possa ver quando a entrada de cache expira.
Após o código que você adicionou na etapa anterior, adicione o seguinte código para inserir o conteúdo do arquivo no objeto de cache como uma CacheItem instância:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Você especifica informações sobre como a entrada de cache deve ser removida passando o CacheItemPolicy objeto criado anteriormente como um parâmetro.
Depois do bloco if/then, adicione o seguinte código para exibir o conteúdo do arquivo armazenado em cache em uma caixa de mensagem:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
No menu Compilar, clique em Compilar WPFCaching para compilar seu projeto.

Testando o cache no Aplicativo WPF

Agora você pode testar o aplicativo.

Para testar o cache no aplicativo WPF

Pressione CTRL+F5 para executar o aplicativo.

A janela MainWindow é exibida.
Clique em Obter Cache.

O conteúdo em cache do arquivo de texto é exibido em uma caixa de mensagem. Observe o carimbo de data/hora no arquivo.
Feche a caixa de mensagem e, em seguida, clique em Obter Cache novamente.

O carimbo de data/hora está inalterado. Isso indica que o conteúdo em cache está exibido.
Aguarde 10 segundos ou mais e, em seguida, clique em Obter Cache novamente.

Agora, um novo carimbo de data/hora é exibido. Isso indica que a política deixou a entrada de cache expirar e que o novo conteúdo armazenado em cache fosse exibido.
Em um editor de texto, abra o arquivo de texto que você criou. Não faça nenhuma alteração ainda.
Feche a caixa de mensagem e, em seguida, clique em Obter Cache novamente.

Observe o carimbo de data/hora novamente.
Faça uma alteração no arquivo de texto e, em seguida, salve o arquivo.
Feche a caixa de mensagem e, em seguida, clique em Obter Cache novamente.

Essa caixa de mensagem contém o conteúdo atualizado do arquivo de texto e um novo carimbo de data/hora. Isso indica que o monitor de alteração do arquivo de host removeu a entrada de cache imediatamente após você alterar o arquivo, mesmo que o tempo limite de expiração absoluto não tenha se expirado.

Observação

Você pode aumentar o tempo de remoção para 20 segundos ou mais para permitir mais tempo para fazer uma alteração no arquivo.

Exemplo de código

Depois de concluir este passo a passo, o código para o projeto que você criou será parecido com o exemplo a seguir.

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