Excepción al agregar la entrada del diccionario

Question

Estamos viendo esta excepción en el siguiente bloque de código en un contexto ASP.NET que se ejecuta en un servidor IIS 7.

1) Exception Information 
********************************************* 
Exception Type: System.Exception 
Message: Exception Caught in Application_Error event 
Error in: InitializationStatus.aspx 
Error Message:An item with the same key has already been added. 
Stack Trace: at 
System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add) 
at CredentialsSession.GetXmlSerializer(Type serializerType) 

Este es el código que la excepción se está produciendo en:

[Serializable()] 
public class CredentialsSession 
{ 
    private static Dictionary<string, System.Xml.Serialization.XmlSerializer> localSerializers = new Dictionary<string, XmlSerializer>(); 

    private System.Xml.Serialization.XmlSerializer GetXmlSerializer(Type serializerType) 
    { 
     string sessionObjectName = serializerType.ToString() + ".Serializer"; 

     if (Monitor.TryEnter(this)) 
     { 
      try 
      { 
       if (!localSerializers.ContainsKey(sessionObjectName)) 
       { 
        localSerializers.Add(sessionObjectName, CreateSerializer(serializerType)); 
       } 
      } 
      finally 
      { 
       Monitor.Exit(this); 
      } 
     } 
     return localSerializers[sessionObjectName]; 
    } 

    private System.Xml.Serialization.XmlSerializer CreateSerializer(Type serializerType) 
    { 
     XmlAttributes xmlAttributes = GetXmlOverrides(); 

     XmlAttributeOverrides xmlOverrides = new XmlAttributeOverrides(); 
     xmlOverrides.Add(typeof(ElementBase), "Elements", xmlAttributes); 

     System.Xml.Serialization.XmlSerializer serializer = 
      new System.Xml.Serialization.XmlSerializer(serializerType, xmlOverrides); 

     return serializer; 
    } 
} 

El Monitor.TryEnter debería ser la prevención de múltiples hilos de entrar en el bloque de forma simultánea, y el código está comprobando el diccionario para verifique que no contenga la clave que se está agregando.

¿Alguna idea sobre cómo podría suceder esto?

Answer 1

Su código no es seguro para subprocesos.

1. Estás bloqueo en this, una instancia CredentialsSession, pero el acceso a un diccionario estático que puede ser compartida por múltiples CredentialsSession casos. Esto explica por qué está recibiendo el error: dos instancias diferentes de CredentialsSession intentan escribir en el diccionario al mismo tiempo.

2. Aunque cambie este para bloquear en un campo estático como se sugiere en la respuesta de @ SLL, no son hilos de proceso seguro, porque no se está fijando al leer el diccionario. Necesita un ReaderWriterLock o ReaderWriterLockSlim para permitir de manera eficiente varios lectores y un solo escritor.

   Por lo tanto, probablemente deba usar un diccionario seguro para subprocesos. ConcurrentDictionary como han dicho otros si está utilizando .NET 4.0. De lo contrario, debe implementar el suyo propio o utilizar una implementación existente, como http://devplanet.com/blogs/brianr/archive/2008/09/26/thread-safe-dictionary-in-net.aspx.

Sus comentarios sugieren que desea evitar llamar CreateSerializer para el mismo tipo varias veces. No sé por qué, porque es probable que el beneficio de rendimiento sea insignificante, ya que es probable que la contención sea rara y no puede exceder una vez para cada tipo durante la vida de la aplicación.

Pero si realmente quieres esto, puede hacerlo de la siguiente manera:

var value; 
if (!dictionary.TryGetValue(key, out value)) 
{ 
    lock(dictionary) 
    { 
     if(!dictionary.TryGetValue(key, out value)) 
     { 
      value = CreateSerializer(...); 
      dictionary[key] = value; 
     } 
    } 
} 

De Comentario:

si puedo aplicar esto con ConcurrentDictionary y simplemente llamo TryAdd (sessionObjectName, CreateSerializer (serializerType)) cada vez.

La respuesta no es llamar a TryAdd cada vez: primero compruebe si está en el diccionario, y luego agregue si no lo está. Una mejor alternativa podría ser usar the GetOrAdd overload que tome un argumento Func.

Answer 2

Pruebe el bloqueo en localSerializers en lugar de this. Por cierto, ¿por qué estás usando el Monitor explícitamente? Sólo una de las razones que veo es proporcionar lock timeout que obviamente no está utilizando, a fin de utilizar simplemente lock() statement vez esto generaría try/finally así:

lock (localSerializers) 
{ 
    if (!localSerializers.ContainsKey(sessionObjectName))     
    {      
     localSerializers.Add(
      sessionObjectName, 
      CreateSerializer(serializerType));     
    } 
} 

EDIT: Puesto que no se ha especificado en las etiquetas que está utilizando .NET 4 se recomienda usar ConcurrentDictionary<TKey, TValue>

---

Monitor.Enter() Method:

Utilice un bloque C# try ... finally (Pruebe ... Finalmente en Visual Basic) para asegurar que libera el monitor, o use la instrucción de bloqueo C# (instrucción SyncLock en Visual Basic), que ajusta los métodos Entrar y Salir en un trato ... finally

Answer 3

Si usted está en .NET Framework 4 o posterior, sugeriría que utilice un ConcurrentDictionary lugar. El método TryAdd mantiene a salvo de este tipo de escenario, sin la necesidad de la basura su código con cerraduras:

localSerializers.TryAdd(sessionObjectName, CreateSerializer(serializerType)) 

Si usted está preocupado por CreateSerializer que se invoca cuando no se necesita, en su lugar debe usar AddOrUpdate:

localSerializers.AddOrUpdate(
    sessionObjectName, 
    key => CreateSerialzer(serializerType), 
    (key, value) => value); 

Esto asegurará que el método se invoque solo cuando necesite generar un nuevo valor (cuando deba agregarse al diccionario). Si ya está presente, la entrada se "actualizará" con el valor ya existente.