¿Cuál es la mejor manera de bloquear el caché en asp.net?

Question

Sé en ciertas circunstancias, como procesos de larga ejecución, es importante bloquear la memoria caché de ASP.NET para evitar solicitudes posteriores por parte de otro usuario para que ese recurso vuelva a ejecutar el proceso largo en lugar de presionar la caché.

¿Cuál es la mejor manera en C# para implementar el bloqueo de caché en ASP.NET?

Answer 1

Aquí está el patrón básico:

• Comprobar la caché del Valu e, volver si a su disposición
• Si el valor no está en la memoria caché, a continuación, aplicar un bloqueo
• dentro de la cerradura, comprobar la memoria caché de nuevo, que podría haber sido bloqueado
• Realice el valor de mirar hacia arriba y almacenar en caché
• Libere el bloqueo

En el código, que se ve así:

private static object ThisLock = new object(); 

public string GetFoo() 
{ 

    // try to pull from cache here 

    lock (ThisLock) 
    { 
    // cache was empty before we got the lock, check again inside the lock 

    // cache is still empty, so retreive the value here 

    // store the value in the cache here 
    } 

    // return the cached value here 

} 

Answer 2

Craig Shoemaker ha hecho un excelente espectáculo en asp.net almacenamiento en caché: http://polymorphicpodcast.com/shows/webperformance/

Answer 3

Este artículo de CodeGuru se explican los distintos escenarios de bloqueo de caché, así como algunas mejores prácticas para ASP.NET bloqueo caché:

Synchronizing Cache Access in ASP.NET

Answer 4

vi un patrón llamado recientemente correcta S tate Patrón de acceso a la bolsa, que parecía tocar esto.

Lo modifiqué un poco para que sea seguro para subprocesos.

http://weblogs.asp.net/craigshoemaker/archive/2008/08/28/asp-net-caching-and-performance.aspx

private static object _listLock = new object(); 

public List List() { 
    string cacheKey = "customers"; 
    List myList = Cache[cacheKey] as List; 
    if(myList == null) { 
     lock (_listLock) { 
      myList = Cache[cacheKey] as List; 
      if (myList == null) { 
       myList = DAL.ListCustomers(); 
       Cache.Insert(cacheKey, mList, null, SiteConfig.CacheDuration, TimeSpan.Zero); 
      } 
     } 
    } 
    return myList; 
} 

Answer 5

Para completar un ejemplo completo sería algo como esto.

private static object ThisLock = new object(); 
... 
object dataObject = Cache["globalData"]; 
if(dataObject == null) 
{ 
    lock(ThisLock) 
    { 
     dataObject = Cache["globalData"]; 

     if(dataObject == null) 
     { 
      //Get Data from db 
      dataObject = GlobalObj.GetData(); 
      Cache["globalData"] = dataObject; 
     } 
    } 
} 
return dataObject; 

Answer 6

Sólo para repetir lo que dijo Pavel, creo que esta es la manera segura de rosca más de escribirlo

private T GetOrAddToCache<T>(string cacheKey, GenericObjectParamsDelegate<T> creator, params object[] creatorArgs) where T : class, new() 
    { 
     T returnValue = HttpContext.Current.Cache[cacheKey] as T; 
     if (returnValue == null) 
     { 
      lock (this) 
      { 
       returnValue = HttpContext.Current.Cache[cacheKey] as T; 
       if (returnValue == null) 
       { 
        returnValue = creator(creatorArgs); 
        if (returnValue == null) 
        { 
         throw new Exception("Attempt to cache a null reference"); 
        } 
        HttpContext.Current.Cache.Add(
         cacheKey, 
         returnValue, 
         null, 
         System.Web.Caching.Cache.NoAbsoluteExpiration, 
         System.Web.Caching.Cache.NoSlidingExpiration, 
         CacheItemPriority.Normal, 
         null); 
       } 
      } 
     } 

     return returnValue; 
    } 

Answer 7

he llegado con el siguiente método de extensión:

private static readonly object _lock = new object(); 

public static TResult GetOrAdd<TResult>(this Cache cache, string key, Func<TResult> action, int duration = 300) { 
    TResult result; 
    var data = cache[key]; // Can't cast using as operator as TResult may be an int or bool 

    if (data == null) { 
     lock (_lock) { 
      data = cache[key]; 

      if (data == null) { 
       result = action(); 

       if (result == null) 
        return result; 

       if (duration > 0) 
        cache.Insert(key, result, null, DateTime.UtcNow.AddSeconds(duration), TimeSpan.Zero); 
      } else 
       result = (TResult)data; 
     } 
    } else 
     result = (TResult)data; 

    return result; 
} 

He usado las respuestas de @John Owen y @ user378380. Mi solución también te permite almacenar valores int y bool dentro de la memoria caché.

Corrígeme si hay algún error o si se puede escribir un poco mejor.

Answer 8

Yo he escrito una biblioteca que resuelve ese tema en particular: Rocks.Caching

También he blog acerca de este problema en detalle y se explica por qué es importante here.

Answer 9

Modifiqué el código de @ user378380 para obtener más flexibilidad.En lugar de devolver, TResult ahora devuelve un objeto para aceptar diferentes tipos en orden. También agregando algunos parámetros para la flexibilidad. Toda la idea pertenece a @ user378380.

private static readonly object _lock = new object(); 


//If getOnly is true, only get existing cache value, not updating it. If cache value is null then  set it first as running action method. So could return old value or action result value. 
//If getOnly is false, update the old value with action result. If cache value is null then  set it first as running action method. So always return action result value. 
//With oldValueReturned boolean we can cast returning object(if it is not null) appropriate type on main code. 


public static object GetOrAdd<TResult>(this Cache cache, string key, Func<TResult> action, 
    DateTime absoluteExpireTime, TimeSpan slidingExpireTime, bool getOnly, out bool oldValueReturned) 
{ 
    object result; 
    var data = cache[key]; 

    if (data == null) 
    { 
     lock (_lock) 
     { 
      data = cache[key]; 

      if (data == null) 
      { 
       oldValueReturned = false; 
       result = action(); 

       if (result == null) 
       {      
        return result; 
       } 

       cache.Insert(key, result, null, absoluteExpireTime, slidingExpireTime); 
      } 
      else 
      { 
       if (getOnly) 
       { 
        oldValueReturned = true; 
        result = data; 
       } 
       else 
       { 
        oldValueReturned = false; 
        result = action(); 
        if (result == null) 
        {        
         return result; 
        } 

        cache.Insert(key, result, null, absoluteExpireTime, slidingExpireTime); 
       } 
      } 
     } 
    } 
    else 
    { 
     if(getOnly) 
     { 
      oldValueReturned = true; 
      result = data; 
     } 
     else 
     { 
      oldValueReturned = false; 
      result = action(); 
      if (result == null) 
      { 
       return result; 
      } 

      cache.Insert(key, result, null, absoluteExpireTime, slidingExpireTime); 
     }    
    } 

    return result; 
} 

Answer 10

No es necesario bloquear toda la instancia de la memoria caché, sino que solo tenemos que bloquear la clave específica para la que está insertando. Es decir No es necesario bloquear el acceso al inodoro femenino mientras usa el inodoro masculino :)

La implementación a continuación permite bloquear claves de caché específicas usando un diccionario concurrente. De esta forma puede ejecutar GetOrAdd() para dos claves diferentes al mismo tiempo, pero no para la misma clave al mismo tiempo.

using System; 
using System.Collections.Concurrent; 
using System.Web; 
using System.Web.Caching; 

public static class CacheExtensions 
{ 
    private static ConcurrentDictionary<string, object> keyLocks = new ConcurrentDictionary<string, object>(); 

    /// <summary> 
    /// Get or Add the item to the cache 
    /// </summary> 
    public static T GetOrAdd<T>(this Cache cache, string key, Func<T> factory, int durationInSeconds, bool synchronised = true) 
     where T : class 
    { 
     // Try and get value from the cache 
     var value = cache.Get(key); 
     if (value == null) 
     { 
      // If not yet cached, lock the key value and add to cache 
      lock (keyLocks.GetOrAdd(key, new object())) 
      { 
       // Try and get from cache again in case it has been added in the meantime 
       value = HttpRuntime.Cache.Get(key); 
       if (value == null && (value = factory()) != null) 
       { 
        HttpRuntime.Cache.Insert(key, 
         value, 
         null, 
         DateTime.Now.AddSeconds(durationInSeconds), 
         Cache.NoSlidingExpiration, 
         CacheItemPriority.Default, 
         null); 
       } 

       // Remove temporary key lock 
       object locker; 
       keyLocks.TryRemove(key, out locker); 
      } 
     } 

     return value as T; 
    } 
}