Tutorial: Almacenar en caché datos de la aplicación en una aplicación de WPF

Artículo
05/04/2023

El almacenamiento en caché permite almacenar datos en memoria para un acceso rápido. Cuando se vuelve a acceder a los datos, las aplicaciones pueden obtenerlos de la memoria caché en lugar de recuperarlos de la fuente original. Esto puede mejorar el rendimiento y la escalabilidad. Además, el almacenamiento en caché permite que los datos estén disponibles cuando el origen de datos no está disponible temporalmente.

.NET Framework proporciona clases que permiten usar el almacenamiento en caché en aplicaciones de .NET Framework. Estas clases se encuentran en el espacio de nombres System.Runtime.Caching.

Nota:

El espacio de nombres System.Runtime.Caching es una novedad de .NET Framework 4. Este espacio de nombres hace que el almacenamiento en caché esté disponible para todas las aplicaciones de .NET Framework. En versiones anteriores de .NET Framework, el almacenamiento en caché solo estaba disponible en el espacio de nombres System.Web y, por tanto, exigía una dependencia de las clases de ASP.NET.

En este tutorial se muestra cómo usar la funcionalidad de almacenamiento en caché disponible en .NET Framework como parte de una aplicación de Windows Presentation Foundation (WPF). En el tutorial, almacenará en caché el contenido de un archivo de texto.

Las tareas que se ilustran en este tutorial son las siguientes:

Creación de un proyecto de aplicación WPF.
Adición de una referencia a .NET Framework 4.
Inicialización de una caché.
Adición de una entrada de caché con el contenido de un archivo de texto.
Suministro una directiva de expulsión para la entrada en caché.
Supervisión de la ruta del archivo en caché y notificación a la instancia en caché de los cambios realizados en el elemento supervisado.

Requisitos previos

Para poder completar este tutorial, necesitará:

Visual Studio 2010.
Un archivo de texto con una pequeña cantidad de texto. (Mostrará el contenido del archivo de texto en un cuadro de mensaje). El código que se muestra en el tutorial supone que está trabajando con el archivo siguiente:

c:\cache\cacheText.txt

Pero puede usar cualquier archivo de texto y realizar pequeños cambios en el código de este tutorial.

Creación de un proyecto de aplicación WPF

Para empezar, creará un proyecto de aplicación WPF.

Para crear una aplicación WPF

Inicie Visual Studio.
En el menú Archivo, haga clic en Nuevo después en Nuevo proyecto.

Se muestra el cuadro de diálogo Nuevo proyecto.
En Plantillas instaladas, seleccione el lenguaje de programación que quiera usar (Visual Basic o Visual C#).
En el cuadro de diálogo Nuevo proyecto, seleccione Aplicación WPF.

Nota:

Si no ve la plantilla Aplicación WPF, asegúrese de que ha seleccionado como destino una versión de .NET Framework que admita WPF. En el cuadro de diálogo Nuevo Project, seleccione .NET Framework 4 en la lista.
En el cuadro de texto Nombre, escriba un nombre para el proyecto. Por ejemplo, puede escribir WPFCaching.
Active la casilla Crear directorio para la solución.
Haga clic en OK.

WPF Designer se abre en la vista Diseño y muestra el archivo MainWindow.xaml. Visual Studio crea la carpeta My Project y los archivos Application.xaml y MainWindow.xaml.

Selección de .NET Framework como destino y adición de una referencia a los ensamblados de almacenamiento en caché

De forma predeterminada, las aplicaciones WPF se destinan al perfil de cliente de .NET Framework 4. Para usar el espacio de nombres System.Runtime.Caching en una aplicación WPF, la aplicación debe tener como destino .NET Framework 4 (no el perfil de cliente .NET Framework 4) y debe incluir una referencia al espacio de nombres.

Por tanto, el siguiente paso consiste en cambiar el destino de .NET Framework y agregar una referencia al espacio de nombres System.Runtime.Caching.

Nota:

El procedimiento para cambiar el destino de .NET Framework es diferente en un proyecto de Visual Basic y en uno de Visual C#.

Para cambiar el destino de .NET Framework en Visual Basic

En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, después, haga clic en Propiedades.

Se muestra la ventana de propiedades de la aplicación.
Haga clic en la pestaña Compilar.
En la parte inferior de la ventana, haga clic en Opciones de compilación avanzadas….

Se muestra el cuadro de diálogo Configuración avanzada del compilador.
En la lista Plataforma de destino (todas las configuraciones), seleccione .NET Framework 4. (No seleccione .NET Framework 4 Client Profile).
Haga clic en OK.

Aparecerá el cuadro de diálogo Cambio de plataforma de destino.
En el cuadro de diálogo Cambio de plataforma de destino, haga clic en Sí.

El proyecto se cierra y después se vuelve a abrir.
Siga estos pasos para agregar una referencia al ensamblado de almacenamiento en caché:
1. En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, después, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET, después System.Runtime.Caching y, luego, haga clic en Aceptar.

Para cambiar el destino de .NET Framework en un proyecto de Visual C#

En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, después, haga clic en Propiedades.

Se muestra la ventana de propiedades de la aplicación.
Haga clic en la pestaña Aplicación .
En la lista Plataforma de destino, seleccione .NET Framework 4. (No seleccione .NET Framework 4 Client Profile).
Siga estos pasos para agregar una referencia al ensamblado de almacenamiento en caché:
1. Haga clic con el botón derecho en la carpeta Referencias y, después, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET, después System.Runtime.Caching y, luego, haga clic en Aceptar.

Adición de un botón a la ventana de WPF

A continuación, agregará un control de botón y creará un controlador de eventos para el evento Click del botón. Más adelante, agregará código para que, al hacer clic en el botón, el contenido del archivo de texto se almacene en caché y se muestre.

Para agregar un control de botón

En el Explorador de soluciones, haga doble clic en el archivo MainWindow.xaml para abrirlo.
En el Cuadro de herramientas, en Controles WPF comunes, arrastre un control Button a la ventana MainWindow.
En la ventana Propiedades, establezca la propiedad Content del control Button en Obtener caché.

Inicialización de la caché y almacenamiento en caché de una entrada

A continuación, agregará el código para realizar las siguientes tareas:

Crear una instancia de la clase en caché; es decir, crear una instancia de un nuevo objeto MemoryCache.
Especificar que la caché use un objeto HostFileChangeMonitor para supervisar los cambios en el archivo de texto.
Leer el archivo de texto y almacenar en caché su contenido como entrada de caché.
Mostrar el contenido del archivo de texto en caché.

Para crear el objeto de caché

Haga doble clic en el botón que acaba de agregar para crear un controlador de eventos en el archivo MainWindow.xaml.cs o MainWindow.Xaml.vb.
En la parte superior del archivo (antes de la declaración de clase), agregue las siguientes instrucciones Imports (Visual Basic) o using (C#):
```
using System.Runtime.Caching;
using System.IO;
```
```
Imports System.Runtime.Caching
Imports System.IO
```
En el controlador de eventos, agregue el código siguiente para crear instancias del objeto de caché:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
ObjectCache es una clase integrada que proporciona una caché de objetos en memoria.

Agregue el código siguiente para leer el contenido de una entrada de caché denominada filecontents:

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

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

Agregue el código siguiente para comprobar si existe la entrada de caché con el nombre filecontents:
```
If fileContents Is Nothing Then

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

}
```
Si la entrada de caché especificada no existe, debe leer el archivo de texto y agregarlo como una entrada de caché a la caché.
En el bloque if/then, agregue el código siguiente para crear un objeto CacheItemPolicy que especifique que la entrada de caché expira después de 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);
```
Si no se proporciona información de expulsión o expiración, el valor predeterminado es InfiniteAbsoluteExpiration, lo que significa que las entradas de caché nunca expiran en función de un tiempo absoluto. En su lugar, las entradas de caché expiran solo cuando hay presión de memoria. Como procedimiento recomendado, siempre debe proporcionar una expiración absoluta o deslizante de forma explícita.
Dentro del bloque if/then y después del código que ha agregado en el paso anterior, agregue el código siguiente a fin de crear una colección para las rutas de archivo que quiera supervisar y para agregar la ruta del archivo de texto a la colección:
```
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");
```
Nota:

Si el archivo de texto que quiere usar no es c:\cache\cacheText.txt, especifique la ruta del archivo de texto que quiera usar.
Después del código que ha agregado en el paso anterior, agregue el código siguiente a fin agregar un objeto HostFileChangeMonitor nuevo a la colección de monitores de cambios para la entrada de caché:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
El objeto HostFileChangeMonitor supervisa la ruta del archivo de texto y notifica a la caché si se producen cambios. En este ejemplo, la entrada de caché expirará si cambia el contenido del archivo.
Después del código que ha agregado en el paso anterior, agregue el código siguiente para leer el contenido del archivo de texto:
```
fileContents = File.ReadAllText("c:\cache\cacheText.txt") & vbCrLf & DateTime.Now.ToString()
```
```
fileContents = File.ReadAllText("c:\\cache\\cacheText.txt") + "\n" + DateTime.Now;
```
La marca de tiempo de fecha y hora se agrega para que pueda ver cuándo expira la entrada de caché.
Después del código que ha agregado en el paso anterior, agregue el código siguiente para insertar el contenido del archivo de texto en el objeto de copiar en caché como una instancia de CacheItem:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Para especificar información sobre cómo se debe expulsar la entrada de caché, pase como parámetro el objeto CacheItemPolicy que ha creado antes.
Después del bloque if/then, agregue el código siguiente para mostrar en un cuadro de mensaje el contenido del archivo en caché:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
Para compilar el proyecto, haga clic en Compilar WPFCaching en el menú Compilar.

Prueba del almacenamiento en caché en la aplicación WPF

Ahora puede probar la aplicación.

Para probar el almacenamiento en caché en la aplicación WPF

Presione CTRL+F5 para ejecutar la aplicación.

Se muestra la ventana MainWindow.
Haga clic en Obtener caché.

El contenido en caché del archivo de texto se muestra en un cuadro de mensaje. Observe la marca de tiempo en el archivo.
Cierre el cuadro de mensaje y, después, vuelva a hacer clic en Obtener caché.

La marca de tiempo no cambia. Esto indica que se muestra el contenido en caché.
Espere 10 segundos o más y, después, vuelva a hacer clic en Obtener caché.

Esta vez se muestra una nueva marca de tiempo. Esto indica que la directiva permite que la entrada de caché expire y que se muestre el nuevo contenido en caché.
En un editor de texto, abra el archivo de texto que ha creado. No realice ningún cambio todavía.
Cierre el cuadro de mensaje y, después, vuelva a hacer clic en Obtener caché.

Observe la marca de tiempo de nuevo.
Realice un cambio en el archivo de texto y guárdelo.
Cierre el cuadro de mensaje y, después, vuelva a hacer clic en Obtener caché.

Este cuadro de mensaje contiene el contenido actualizado del archivo de texto y una nueva marca de tiempo. Esto indica que el monitor de cambios de archivo de host ha expulsado la entrada de caché inmediatamente cuando ha modificado el archivo, aunque el período de tiempo de espera absoluto no haya expirado.

Nota:

Puede aumentar el tiempo de expulsión a 20 segundos o más a fin de permitir más tiempo para realizar un cambio en el archivo.

Ejemplo de código

Una vez que haya completado este tutorial, el código del proyecto que ha creado será similar al ejemplo siguiente.

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