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

2025-05-07

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 obtener los datos de la memoria caché en lugar de recuperarlos del origen original. Esto puede mejorar el rendimiento y la escalabilidad. Además, el almacenamiento en caché hace 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 System.Runtime.Caching espacio de nombres .

Nota:

El System.Runtime.Caching espacio de nombres es nuevo en .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 System.Web espacio de nombres y, por tanto, requería una dependencia de clases de ASP.NET.

En este tutorial se muestra cómo usar la funcionalidad de almacenamiento en caché que está 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.

Entre las tareas que se muestran en este tutorial se incluyen las siguientes:

Creación de un proyecto de aplicación WPF.
Agregar una referencia a .NET Framework 4.
Inicialización de una memoria caché.
Agregar una entrada de caché que contenga el contenido de un archivo de texto.
Establecer una política de expulsión para la entrada de caché.
Supervisar la ruta de acceso del archivo almacenado en caché y notificar a la instancia de caché los cambios realizados en el elemento supervisado.

Prerrequisitos

Para completar este tutorial, necesitará lo siguiente:

Visual Studio 2010.
Un archivo de texto que contiene 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 siguiente archivo:

c:\cache\cacheText.txt

Sin embargo, 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 de WPF

Empezará creando un proyecto de aplicación WPF.

Para crear una aplicación WPF

Inicie Visual Studio.
En el menú Archivo, haga clic en Nuevo y, a continuación, haga clic en Nuevo Proyecto.

Se muestra el cuadro de diálogo Nuevo proyecto .
En Plantillas instaladas, seleccione el lenguaje de programación que desea 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 de WPF , asegúrese de que tiene como destino una versión de .NET Framework que admita WPF. En el cuadro de diálogo Nuevo proyecto , 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 .
Haz clic en Aceptar.

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

Establecer como destino .NET Framework y agregar una referencia a los ensamblados de almacenamiento en caché

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

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

Nota:

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

Para cambiar el .NET Framework de destino en Visual Basic

En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, a continuación, 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 Perfil de cliente de .NET Framework 4).
Haz clic en Aceptar.

Se muestra el cuadro de diálogo Cambio de marco de destino.
En el cuadro de diálogo Cambio de marco de destino, haga clic en Sí.

El proyecto está cerrado y, a continuación, se vuelve a abrir.
Agregue una referencia al ensamblado de almacenamiento en caché siguiendo estos pasos:
1. En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, a continuación, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET , seleccione System.Runtime.Cachingy haga clic en Aceptar.

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

En el Explorador de soluciones, haga clic con el botón derecho en el nombre del proyecto y, a continuación, 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 Perfil de cliente de .NET Framework 4).
Agregue una referencia al ensamblado de almacenamiento en caché siguiendo estos pasos:
1. Haga clic con el botón derecho en la carpeta Referencias y, a continuación, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET , seleccione System.Runtime.Cachingy haga clic en Aceptar.

Agregar 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 del Click botón. Más adelante agregará código para que, al hacer clic en el botón, el contenido del archivo de texto se almacenará en caché y se mostrará.

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 comunes de WPF, arrastre un Button control a la MainWindow ventana.
En la ventana Propiedades , establezca la Content propiedad del Button control en Obtener caché.

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

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

Cree una instancia de la clase de caché; es decir, creará una instancia de un nuevo MemoryCache objeto.
Especifique que la memoria caché usa un HostFileChangeMonitor objeto para supervisar los cambios en el archivo de texto.
Lea el archivo de texto y almacene en caché su contenido como entrada de caché.
Muestra el contenido del archivo de texto almacenado 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 Imports instrucciones (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
```
La ObjectCache clase es una clase integrada que proporciona una memoria 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é denominada 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 memoria caché.
En el if/then bloque , agregue el código siguiente para crear un nuevo CacheItemPolicy objeto 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 explícitamente una expiración absoluta o deslizante.
Dentro del if/then bloque y siguiendo el código que agregó en el paso anterior, agregue el código siguiente para crear una colección para las rutas de acceso de archivo que desea supervisar y agregar la ruta de acceso 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 desea usar no es el c:\cache\cacheText.txt, especifique la ruta de acceso donde se encuentra el archivo de texto que desea usar.
Después del código que agregó en el paso anterior, agregue el código siguiente para agregar un nuevo HostFileChangeMonitor objeto 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 HostFileChangeMonitor objeto supervisa la ruta de acceso del archivo de texto y notifica a la memoria 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 agregó 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;
```
Se agrega la marca de tiempo para que pueda ver cuándo expira la entrada de caché.
Después del código que agregó en el paso anterior, agregue el código siguiente para insertar el contenido del archivo en el objeto de caché como una CacheItem instancia:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Especifique información sobre cómo se debe expulsar la entrada de caché pasando el CacheItemPolicy objeto que creó anteriormente como parámetro.
Después del if/then bloque, agregue el código siguiente para mostrar el contenido del archivo almacenado en caché en un cuadro de mensaje:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
En el menú Compilar , haga clic en Compilar WPFCaching para compilar el proyecto.

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 MainWindow ventana.
Haga clic en Obtener caché.

El contenido almacenado 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, a continuación, haga clic en Obtener caché de nuevo.

La marca de tiempo no cambia. Esto indica que se muestra el contenido almacenado en caché.
Espere 10 segundos o más y, a continuación, haga clic en Obtener caché de nuevo.

Esta vez se muestra una nueva marca de tiempo. Esto indica que la directiva permite que la entrada de caché expire y que se muestra el nuevo contenido almacenado en caché.
En un editor de texto, abra el archivo de texto que creó. Aún no realice ningún cambio.
Cierre el cuadro de mensaje y, a continuación, haga clic en Obtener caché de nuevo.

Observe la marca de tiempo de nuevo.
Realice un cambio en el archivo de texto y guarde el archivo.
Cierre el cuadro de mensaje y, a continuación, haga clic en Obtener caché de nuevo.

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 del archivo del host expulsó la entrada de caché inmediatamente cuando cambió el archivo, aunque el plazo de espera absoluto no hubiera expirado.

Nota:

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

Ejemplo de código

Una vez completado este tutorial, el código del proyecto que creó 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