Variables de Cache

En general, todo el tema de la cache de ASP.NET te entra por los ojitos y es otro de los puntos que te hace decidirte por esta plataforma de creación Web en lugar de cualquier otra.

No nos equivocamos si decimos que la (correcta) utilización de la cache permite una tremenda mejora del performance de nuestra aplicación.

Llegada esta afirmación "mejora de performance", surge la inteligente pregunta de ¿En qué punto se cortan las rectas de "gasto por acceso a datos" y "gasto por almacenamiento de cache", tabulado por la cantidad de accesos que se hacen + el tamaño de esos datos?

Hemos de tener en cuenta que, en el 90% de los casos, el mayor gasto de recursos se realiza en los accesos a Base de Datos (el evitar accesos a la BBDD es un ejemplo típico de uso de variables de cache). Pero también es cierto que la memoria de nuestro servidor (sobretodo si es compartido) no es infinita y si parte de esa memoria no se usa, se borra... entonces, ¿Cuándo conviene utilizar las variables de cache?

Supongamos varios escenarios de casos bastante típicos, en los que se recoge un resultado de 1000 columnas de la BBDD:

Escenario 1
- Nuestra página la acceden 100 personas por minuto.
- Cada vez que lo hacen realizamos un acceso a base de datos.
- Esa información apenas cambia un par de veces cada hora
Conclusión: probablemente convenga utilizar variables de cache

Escenario 2

- Nuestra página la acceden 100 personas cada hora
- Cada vez que lo hacen realizamos dos accesos a base de datos.
- La información cambia una vez a la semana.
Conclusión: aunque la información cambia cada mucho tiempo, no parece necesario ahorrarnos cuatros simples accesos por minuto.

En última instancia, la decisión depende de vuestras pruebas y experiencias. En un futuro publicaré algún artículo haciendo pruebas de eficiencia al respecto.

A lo largo de este artículo vamos a trabajar específicamente con las variables de cache, el modo en que, mediante código, almacenamos información en la cache.

¿Cómo se utiliza una variable de cache?
Es muy sencillo. Su uso es muy similar al de las variables de sesión o aplicación. Veamos un ejemplo en el que se guarda en una variable de cache el momento en que la hemos guardado, y posteriormente recogemos ese momento y lo guardamos en una variable DateTime:

    Cache["miprimeraVariable"] = DateTime.Now;
    //...
    DateTime cuando = (DateTime)Cache["miprimeraVariable"];


Ejemplo de uso eficiente
Veamos un ejemplo de uso eficiente de variables de Cache. Supongamos que accedemos a una base de datos y con su resultado rellenamos una lista genérica de 10.000 componentes. Para ahorrarnos ese acceso tan gordo, sobretodo si lo exigimos varias veces por segundo, haríamos algo como:

variablesCache.cs
    public static List<Person> recogePersonasBLL()
    {
        List<Person> personas = (List<Person>)Cache["personas"];

        if (null == personas)
        {
            personas = miDAL.recogePersonasDAL();

            Cache.Insert("personas", personas, null, DateTime.Now.AddMinutes(5), TimeSpan.Zero);
        }
        return personas;
    }


Como véis, lo primero que hacemos es comprobar si nuestro listado de personas está almacenada en la variable de cache. Si es así, ya no hacemos nada más, nos hemos ahorrado un gordo acceso a BBDD y devolvemos el listado.

Si no existiera esa variable de Cache, bien porque hubiera caducado o bien porque no la habíamos creado hasta ahora, entonces realizamos el acceso a la base de datos y guardamos esos datos en una variable de cache:

            Cache.Insert("personas", personas, null, DateTime.Now.AddMinutes(5), TimeSpan.Zero);

En el primer parámetro asignamos el nombre de esa variable de cache.
En el segundo ubicamos la propia variable a almacenar.
El tercer parámetros define ciertas dependencias de la cache, pero en nuestro sencillo ejemplo no nos interesa y le damos un valor de null.
En cuanto al cuarto parámetro, definimos el tiempo absoluto de caducidad de la variable de cache. En nuestro caso, caducará 5 minutos después de haberla creado.
El último parámetro es el tiempo relativo de caducidad, que es el tiempo que pasa desde la última vez que hemos accedido a la variable de cache. Por ejemplo, si hubiéramos indicado un tiempo relativo de 5 minutos, la variable hubiera caducado 5 minutos después de la última vez que se ha accedido (de cualquier modo) a esa variable de cache.

Habitualmente, el mayor problema con el que nos enfrentamos cuando trabajamos con variable de cache es la sincronización entre los datos reales que hay en la BBDD y los datos que hay almacenados en la variable de cache. con SQLServer 2005 esa sincronización la podemos definir como automática: "Cuando alguien cambio ciertos datos de alguna de tus tablas, guarda automáticamente los cambios en la variable de cache que te digamos".

Sin embargo, en la mayor parte de los casos vale con definir una caducidad apropiada, que en algunas aplicaciones será de un tiempo absoluto de 5 minutos, en otra puede ser de algunas horas, y en otras puede convenir que sea definida una caducidad relativa.


Pues poco más que añadir!! Animaos a utilizar el enorme poder de las variables de cache!!