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

Artículo
08/10/2011

El almacenamiento en caché permite almacenar los datos en memoria para poder acceder a ellos rápidamente. Cuando se tiene acceso de nuevo a los datos, las aplicaciones pueden obtener los datos de la memoria caché en lugar de recuperarlos del origen inicial. Esto puede mejorar el rendimiento y la escalabilidad. Además, con el almacenamiento en caché, los datos siguen estando disponibles si el origen de datos temporalmente no lo está.

.NET Framework proporciona clases que permiten usar el almacenamiento en caché en las 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 nuevo en .NET Framework 4.Con este espacio de nombres, el almacenamiento en caché está disponible en 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, necesitaba una dependencia en las clases de ASP.NET.

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

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

Crear un proyecto de aplicación WPF.
Agregar una referencia a .NET Framework 4.
Inicializar una memoria caché.
Agregar una entrada de caché que tenga el contenido de un archivo de texto.
Proporcionar una directiva de expulsión para la entrada en caché.
Supervisar la ruta de acceso del archivo en caché y notificar a la instancia de caché los cambios que se producen en el elemento supervisado.

Requisitos previos

Para poder completar este tutorial, necesitará:

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

c:\cache\cacheText.txt

Sin embargo, puede utilizar cualquier archivo de texto y realizar pequeños cambios en el código de este tutorial.

Crear 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 y, a continuación, en Nuevo proyecto.

Aparecerá el cuadro de diálogo Nuevo proyecto.
En Plantillas instaladas, seleccione el lenguaje de programación que desee utilizar (Visual Basic o Visual C#).

En el cuadro de diálogo Nuevo proyecto, seleccione Aplicación WPF.

Nota
Si la plantilla Aplicación WPF no está visible, asegúrese de utilizar 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 especificar WPFCaching.
Active la casilla Crear directorio para la solución.
Haga clic en Aceptar.

WPF Designer se abrirá en la Vista de diseño con el archivo MainWindow.xaml. Visual Studio crea la carpeta My Project, el archivo Application.xaml y el archivo MainWindow.xaml.

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

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

Por consiguiente, el paso siguiente es cambiar la versión de .NET Framework de destino y agregar una referencia al espacio de nombres System.Runtime.Caching.

Nota
El procedimiento para cambiar la versión de .NET Framework de destino es diferente en un proyecto de Visual Basic y en un proyecto de Visual C#.

Para cambiar la versión de .NET Framework de destino en Visual Basic

En el Explorador de soluciones, haga clic con el botón secundario en el nombre del proyecto y, a continuación, haga clic en Propiedades.

Se mostrará la ventana Propiedades de la aplicación.
Haga clic en la ficha 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 de compilador avanzada.
En la lista Versión de .NET Framework de destino (todas las configuraciones), seleccione .NET Framework 4. No seleccione .NET Framework 4 Client Profile.
Haga clic en Aceptar.

Aparecerá el cuadro de diálogo Cambio de versión de .NET Framework de destino.
En el cuadro de diálogo Cambio de versión de .NET Framework de destino, haga clic en Sí.

El proyecto se cierra y 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 secundario en el nombre del proyecto y, a continuación, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET, seleccione System.Runtime.Caching y, a continuación, haga clic en Aceptar.

Para cambiar la versión de .NET Framework de destino de un proyecto de Visual C#

En el Explorador de soluciones, haga clic con el botón secundario en el nombre del proyecto y, a continuación, haga clic en Propiedades.

Se mostrará la ventana Propiedades de la aplicación.
Haga clic en la ficha Aplicación.
En la lista Versión de .NET Framework de destino, seleccione .NET Framework 4. (No seleccione .NET Framework 4 Client Profile).
Agregue una referencia al ensamblado de almacenamiento en caché siguiendo estos pasos:
1. Haga clic con el botón secundario del mouse en la carpeta Referencias y, a continuación, haga clic en Agregar referencia.
2. Seleccione la pestaña .NET, seleccione System.Runtime.Caching y, a continuación, 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 Click del botón. Agregará más adelante código de modo que, cuando se haga 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.
Desde 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 Get Cache.

Inicializar la memoria caché y almacenar una entrada en caché

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

Crear una instancia de la clase Cache; es decir, crear una instancia de un nuevo objeto MemoryCache.
Especificar que la memoria caché use un objeto HostFileChangeMonitor para supervisar los cambios del archivo de texto.
Leer el archivo de texto y almacenar en caché su contenido como entrada.
Mostrar 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 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 una instancia del objeto de caché:
```
ObjectCache cache = MemoryCache.Default;
```
```
Dim cache As ObjectCache = MemoryCache.Default
```
La clase ObjectCache es una clase integrada que proporciona una memoria caché de objetos en memoria.

Agregue el siguiente código 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 siguiente código para comprobar si la entrada de caché denominada filecontents existe:
```
If fileContents Is Nothing Then

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

}
```
Si la entrada de la memoria caché especificada no existe, debe leer el archivo de texto y agregarlo a la memoria caché como entrada.
En el bloque if/then, agregue el siguiente código para crear un nuevo objeto CacheItemPolicy que especifique que la entrada de caché expire 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é no expiran nunca solo en función de un valor de tiempo absoluto. Por el contrario, las entradas de caché únicamente expirarán cuando haya presión de memoria. Como procedimiento recomendado, debería proporcionar siempre explícitamente un valor absoluto o una fecha de expiración variable.
En el bloque if/then, detrás el código que agregó en el paso anterior, agregue el siguiente código con el fin de crear una colección para las rutas de acceso del archivo que desea supervisar y para 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 utilizar no es c:\cache\cacheText.txt, especifique la ruta de acceso donde se encuentra el archivo de texto que desea utilizar.
Detrás del código que agregó en el paso anterior, agregue el siguiente código para incorporar un nuevo objeto HostFileChangeMonitor a la colección de supervisores de cambios de la entrada de caché:
```
policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))
```
```
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
```
El objeto HostFileChangeMonitor supervisa la ruta de acceso del archivo de texto y notifica a la memoria caché si se produce algún cambio. En este ejemplo, la entrada de caché expirará si el contenido del archivo cambia.
Detrás del código que agregó en el paso anterior, agregue el código siguiente al método 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 de fecha y hora de modo que pueda ver cuándo expira la entrada de caché.
Detrá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 instancia de CacheItem:
```
cache.Set("filecontents", fileContents, policy)
```
```
cache.Set("filecontents", fileContents, policy);
```
Puede especificar información sobre cómo debe expulsarse la entrada de caché pasando el objeto CacheItemPolicy que creó previamente como parámetro del método.
Detrás del bloque if/then, agregue el siguiente código para mostrar el contenido del archivo almacenado en caché en un cuadro de mensaje:
```
MessageBox.Show(fileContents)
```
```
MessageBox.Show(fileContents);
```
En el menú Generar, haga clic en Generar WPFCaching para compilar el proyecto.

Nota
Si el archivo de texto que desea utilizar no es c:\cache\cacheText.txt, especifique la ruta de acceso donde se encuentra el archivo de texto que desea utilizar.

Probar el almacenamiento en caché en la aplicación WPF

Ya 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 Get Cache.

El contenido almacenado en caché del archivo de texto se muestra en un cuadro de mensaje. Observe la marca de tiempo del archivo.
Cierre el cuadro de mensaje y, a continuación, haga clic en Get Cache de nuevo.

La marca de tiempo no ha cambiado. Esto indica que se va a mostrar el contenido almacenado en caché.
Espere 10 segundos o más y, a continuación, haga clic de nuevo en Get Cache.

Ahora aparece una nueva marca de tiempo. Esto indica que la directiva ha permitido que la entrada de caché expire y que se muestra el nuevo contenido almacenado.
En un editor de texto, abra el archivo de texto que creó. No realice ninguna modificación todavía.
Cierre el cuadro de mensaje y, a continuación, haga clic en Get Cache de nuevo.

Observe la marca de tiempo de nuevo.
Realice un cambio en el archivo de texto y, a continuación, guarde el archivo.
Cierre el cuadro de mensaje y, a continuación, haga clic en Get Cache una vez más.

Este cuadro de mensaje incluye el contenido actualizado del archivo de texto y una nueva marca de tiempo. Esto indica que el supervisor de cambios del archivo host expulsó la entrada de caché inmediatamente cuando cambió el archivo, aunque el período de tiempo de espera absoluto no había expirado.

Nota

Puede aumentar el tiempo de expulsión a 20 segundos o más si desea disponer de más tiempo para modificar el archivo.

Nota
Puede aumentar el tiempo de expulsión a 20 segundos o más si desea disponer de más tiempo para modificar el archivo.

Ejemplo de código

Después de completar este tutorial, el código del proyecto que creó tendrá un aspecto similar al del ejemplo siguiente.

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

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


        }
    }
}

Vea también

Referencia

MemoryCache

ObjectCache

System.Runtime.Caching

Conceptos

Almacenamiento en caché en aplicaciones .NET Framework