Creación de bloqueos dinámicos en tiempo de ejecución en ASP.NET

Question

¿Las siguientes suposiciones son válidas para este código? Puse información de fondo debajo del código, pero no creo que sea relevante.

Supuesto 1: Dado que esta es una sola aplicación, supongo que será manejada por un único proceso. Por lo tanto, las variables estáticas se comparten entre subprocesos y declarar que mi colección de objetos de bloqueo estática es válida.

Supuesto 2: Si sé que el valor ya está en el diccionario, no es necesario que bloquee la lectura. Podría usar un ConcurrentDictionary, pero creo que este estará seguro ya que no estoy enumerando (o borrando), y el valor existirá y no cambiará cuando llamo al UnlockOnValue().

Suposición 3: Puedo bloquear la colección Keys, ya que esa referencia no cambiará, incluso si la estructura de datos subyacente sí lo hace.

private static Dictionary<String,Object> LockList = 
    new Dictionary<string,object>(); 

private void LockOnValue(String queryStringValue) 
{ 
    lock(LockList.Keys) 
    { 
     if(!LockList.Keys.Contains(queryStringValue)) 
     { 
      LockList.Add(screenName,new Object()); 
     } 
     System.Threading.Monitor.Enter(LockList[queryStringValue]); 
    } 
} 

private void UnlockOnValue(String queryStringValue) 
{ 
    System.Threading.Monitor.Exit(LockList[queryStringValue]); 
} 

Entonces me gustaría utilizar este código como:

LockOnValue(Request.QueryString["foo"]) 
//Check cache expiry 
//if expired 
    //Load new values and cache them. 
//else 
    //Load cached values 
UnlockOnValue(Request.QueryString["foo"]) 

Antecedentes: Estoy creando una aplicación en ASP.NET que descarga datos basados ​​en una sola variable definida por el usuario en la consulta cuerda. La cantidad de valores será bastante limitada. Necesito almacenar en caché los resultados para cada valor por un período de tiempo específico.

Approach: Decidí usar archivos locales para almacenar en caché los datos, lo cual no es la mejor opción, pero quería probarlo ya que no es crítico y el rendimiento no es un gran problema. Usé 2 archivos por opción, uno con la fecha de caducidad de la memoria caché y otro con los datos.

Problema: No estoy seguro de cuál es la mejor manera de hacer el bloqueo, y no estoy demasiado familiarizado con problemas de enhebrado en .NET (una de las razones por las que elegí este enfoque). De acuerdo con lo que está disponible, y lo que leo, pensé que lo anterior debería funcionar, pero no estoy seguro y quería una segunda opinión.

Answer 1

Su solución actual se ve bastante bien. Las dos cosas que cambiaría:

1: UnlockOnValue debe ir en un bloque finally. Si se lanza una excepción, nunca liberará su bloqueo.

2: LockOnValue es algo ineficiente, ya que hace una búsqueda en el diccionario dos veces.Esto no es un gran problema para un diccionario pequeño, pero para uno más grande querrás cambiar a TryGetValue.

Además, su hipótesis 3 es válida, al menos por ahora. Pero el contrato del diccionario no garantiza que la propiedad Keys siempre devuelva el mismo objeto. Y como es muy fácil no confiar en esto, recomendaría no hacerlo. Cada vez que necesito un objeto para cerrar, simplemente creo un objeto para ese único propósito. Algo como:

private static Object _lock = new Object(); 

Answer 2

lock tiene un alcance de un solo proceso. Si desea abarcar procesos, tendrá que usar primitivas como Mutex (nombrado).

lock es lo mismo que Monitor.Enter y Monitor.Exit. Si también hace Monitor.Enter y Monitor.Exit, está siendo redundante.

No necesita bloquear en lectura, pero debe bloquear la "transacción" de comprobar si el valor no existe y agregarlo. Si no bloquea esa serie de instrucciones, podría haber algo más entre cuando comprueba la clave y cuando la agrega y la agrega, lo que da como resultado una excepción. El bloqueo que está haciendo es suficiente para hacer eso (no necesita las llamadas adicionales para Entrar y Salir, el bloqueo lo hará por usted).