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

Artigo
12/20/2024

O cache permite armazenar 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 disponibiliza dados quando a fonte de dados está temporariamente indisponível.

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

Observação

O namespace System.Runtime.Caching é novo no .NET Framework 4. Esse namespace faz com que o cache esteja disponível para todos os aplicativos do .NET Framework. Em versões anteriores do .NET Framework, o cache estava disponível apenas no namespace System.Web e, portanto, exigia uma dependência de classes 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ê armazena em cache o conteúdo de um arquivo de texto.

As tarefas ilustradas neste passo a passo incluem o seguinte:

Criando um projeto de aplicativo WPF.
Adicionando uma referência ao .NET Framework 4.
Inicializando um cache.
Adicionar uma entrada de cache que contém o conteúdo de um arquivo de texto.
Fornecendo uma política de remoção para a entrada de cache.
Monitorando o caminho do arquivo armazenado em cache e notificando a instância de cache sobre alterações no item monitorado.

Pré-requisitos

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

Visual Studio 2010.
Um arquivo de texto que contém 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ê esteja 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.

Criando um projeto de aplicativo WPF

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

Para criar um aplicativo WPF

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

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

Observação

Se não vir o modelo WPF Application, certifique-se de que está a usar uma versão do .NET Framework que suporte o WPF. Na caixa de diálogo New Project, selecione .NET Framework 4 na lista.
Na caixa de texto Nome , insira um nome para seu projeto. Por exemplo, você pode inserir WPFCaching.
Selecione a caixa de verificação Criar diretório para a solução.
Clique OK.

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

Direcionando o .NET Framework e adicionando uma referência aos assemblies de cache

Por padrão, os aplicativos WPF destinam-se ao .NET Framework 4 Client Profile. Para usar o namespace System.Runtime.Caching em um aplicativo WPF, o aplicativo deve ter como destino o .NET Framework 4 (não o .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 namespace System.Runtime.Caching.

Observação

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

Para alterar o .NET Framework de destino no Visual Basic

No Solutions Explorer, clique com o botão direito do rato no nome do projeto e, em seguida, clique em Propriedades.

A janela de propriedades do 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 OK.

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

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

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

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

A janela de propriedades do aplicativo é exibida.
Clique no separador Aplicação.
Na lista estrutura de destino, selecione .NET Framework 4. (Não selecione .NET Framework 4 Client Profile.)
Adicione uma referência ao conjunto de cache seguindo estas etapas:
1. Clique com o botão direito do rato na pasta Referências e, em seguida, clique em Adicionar Referência.
2. Selecione a guia .NET, selecione System.Runtime.Cachinge, em seguida, clique em OK.

Adicionando 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. Mais tarde, você adicionará código para que, quando você clicar no botão, o conteúdo do arquivo de texto seja 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, sobControles WPF Comuns , arraste um controlo para a janela .
Na janela Properties, defina a propriedade Content do controle Button como Get Cache.

Inicializando o cache e armazenando em cache uma entrada

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

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

Para criar o objeto de 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 classe ObjectCache é 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 existir, você deverá ler o arquivo de texto e adicioná-lo como uma entrada de cache ao cache.
No bloco if/then, adicione o código a seguir para criar um novo objeto CacheItemPolicy 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 apenas quando há pressão de memória. Como prática recomendada, deve-se sempre fornecer explicitamente uma expiração absoluta ou deslizante.
Dentro do bloco if/then e seguindo o 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 estiver c:\cache\cacheText.txt, especifique o caminho onde o arquivo de texto está que você deseja usar.
Seguindo o código que você adicionou na etapa anterior, adicione o seguinte código para adicionar um novo objeto HostFileChangeMonitor à 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 objeto HostFileChangeMonitor 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.
Seguindo 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 registo de data e hora é adicionado para que possas ver quando a entrada de cache expira.
Seguindo 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 instância CacheItem:
```
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 objeto CacheItemPolicy que você criou anteriormente como um parâmetro.
Após o 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 Build, clique em Build WPFCaching para criar o 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 Obter cache.

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

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

Desta vez, um novo timestamp é mostrado. Isso indica que a política permite que a entrada de cache expire e que o novo conteúdo armazenado em cache seja 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.

Esta 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 host removeu a entrada de cache imediatamente quando você alterou o arquivo, mesmo que o período de tempo limite absoluto não tenha expirado.

Observação

Você pode aumentar o tempo de remoção para 20 segundos ou mais para dar 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á semelhante ao 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

Partilhar via