[Article] Asp.Net Core | Mejorar el rendimiento de nuestras Apps con Cache

Uno de nuestros clientes nos pidió que analicemos su aplicación para que aumente su rendimiento. Lo primero que pensamos es usar caché. Asp.Net Core, como otras versiones, tiene un muy buen soporte de Caché en memoria. Trataremos ese tema a continuación.

Objetivo

El objetivo de esta publicación es tocar las posibles utilizaciones y alcance del manejo de del caché en memoria como también que es y para qué son útiles.
Audiencia

Este documento está dirigido a desarrolladores que quieren conocer Asp.Net Core o personas que desarrollan tareas de consultoría de desarrollo o que simplemente están interesados en leer e investigar sobre la tecnología alcanzada por esta publicación.

Desarrollo

Usar caché puede aumentar significa mente la performance y la escalabilidad de nuestra aplicación reduciendo el costo en la generación de contenido. Una buena recomendación es la utilización de cache en los datos que cambia con poca frecuencia. Por ejemplo, si tenemos datos recuperados de una base de datos que no es modificada nunca o muy pocas veces, podemos guardar en caché estos datos, por un cierto tiempo, sin la necesidad de consultar todo el tiempo la base de datos o su datasource.

Asp.Net Core, como otra versión, tiene diferentes tipos de cache que podemos utilizar. El más común es un caché basado en memoria el cual es el más utilizado. Este caché es almacenado en la memoria del WebServer.

Para usar cache en memoria debemos hacer uso de IMemoryCache primer debemos utilizar el packete nuget “Microsoft.Extensions.Caching.Memory”, luego, esto debemos inyectarlo como servicio. Veamos el siguiente código el siguiente código:

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddMemoryCache();
services.AddMvc();
}

public void Configure(IApplicationBuilder app)
{
app.UseMvcWithDefaultRoute();
}
}

La configuración de nuestro controller deberia ser de la siguiente manera:

public class HomeController : Controller
{
private IMemoryCache _cache;

public HomeController(IMemoryCache memoryCache)
{
_cache = memoryCache;
}

Un método muy util es TryGetValue. Este método nos provee la capacidad de verificar si existe un objeto en el caché por medio de una Key. Si existe nos devuelve como salida el existente.


public IActionResult CacheTryGetValueSet()
{
DateTime cacheEntry;

// Look for cache key.
if (!_cache.TryGetValue(CacheKeys.Entry, out cacheEntry))
{
// Key not in cache, so get data.
cacheEntry = DateTime.Now;

// Set cache options.
var cacheEntryOptions = new MemoryCacheEntryOptions()
// Keep in cache for this time, reset time if accessed.
.SetSlidingExpiration(TimeSpan.FromSeconds(3));

// Save data in cache.
_cache.Set(CacheKeys.Entry, cacheEntry, cacheEntryOptions);
}

return View("Cache", cacheEntry);
}

Unos métodos más simplistas son GetOrCreate(), creo que el nombre lo dice todo y tambien como la gran mayoria de Asp.Net Core tenemos la posibilidad de utilizarlo de un modo asincrónico por medio de GetOrCrareAsyn().

public IActionResult CacheGetOrCreate()
{
var cacheEntry = _cache.GetOrCreate(CacheKeys.Entry, entry =>
{
entry.SlidingExpiration = TimeSpan.FromSeconds(3);
return DateTime.Now;
});

return View("Cache", cacheEntry);
}

public async Task<IActionResult> CacheGetOrCreateAsync()
{
var cacheEntry = await
_cache.GetOrCreateAsync(CacheKeys.Entry, entry =>
{
entry.SlidingExpiration = TimeSpan.FromSeconds(3);
return Task.FromResult(DateTime.Now);
});

return View("Cache", cacheEntry);
}

Nuestro cache en memoria puede ser parametrizado por medio de MemoryCacheEntryOptions. podemos configurar:

  • Un tiempo de experiencia. Es el máximo tiempo que va a mantenerse este y permite renovarlo continuamente.
  • Si el cache es consultado se renueva el tiempo de expiración.
  • Se puede establecer para que nunca se remueva o expire.
  • Por medio de PostEvictionDelegate podemos asociar une evento cuando el cache sea removido.

Veamos los ejemplos en código:

public IActionResult CreateCallbackEntry()
{
var cacheEntryOptions = new MemoryCacheEntryOptions()
// Pin to cache.
.SetPriority(CacheItemPriority.NeverRemove)
// Add eviction callback
.RegisterPostEvictionCallback(callback: EvictionCallback, state: this);

_cache.Set(CacheKeys.CallbackEntry, DateTime.Now, cacheEntryOptions);

return RedirectToAction("GetCallbackEntry");
}

public IActionResult GetCallbackEntry()
{
return View("Callback", new CallbackViewModel
{
CachedTime = _cache.Get<DateTime?>(CacheKeys.CallbackEntry),
Message = _cache.Get<string>(CacheKeys.CallbackMessage)
});
}

public IActionResult RemoveCallbackEntry()
{
_cache.Remove(CacheKeys.CallbackEntry);
return RedirectToAction("GetCallbackEntry");
}

private static void EvictionCallback(object key, object value,
EvictionReason reason, object state)
{
var message = $"Entry was evicted. Reason: {reason}.";
((HomeController)state)._cache.Set(CacheKeys.CallbackMessage, message);
}

Conclusión

Asp.Net Core posee un excelente soporte la utilización de cache en memoria la cual nosotros podemos aprovechar para aumentar el rendimiento de nuestras aplicaciones. En próximo post hablaremos de la utilización de cache distribuido a nivel global y otras técnicas para aumentar el rendimiento de nuestras aplicaciones web.