Générer une exception NullReferenceException tout en appelant la set_item méthode d'un objet Dictionary dans un multi-threading scénario

Que l'exception se produit à l'interne dans le Dictionary code, cela signifie que vous accédez à la même Dictionary exemple à partir de plusieurs threads en même temps.

Vous avez besoin de synchroniser le code dans le GetInstance méthode de sorte qu'un seul thread à la fois accède à la Dictionary.

Edit:

Verrou autour de l'accès séparément, de sorte que vous n'êtes pas à l'intérieur d'une serrure tout en faisant de la (soi-disant) de temps de chargement:

private static object _sync = new object();

public static object GetInstance(string key) {
   object instance = null;
   bool found;
   lock (_sync) {
      found = Instances.TryGetValue(key, out instance);
   }
   if (!found) {
      instance = LoadInstance(key);
      lock (_sync) {
         object current;
         if (Instances.TryGetValue(key, out current)) {
            //some other thread already loaded the object, so we use that instead
            instance = current;
         } else {
            Instances[key] = instance;
         }
      }
   }
   return instance;
}

Pour citer http://msdn.microsoft.com/en-us/library/xfhwa508.aspx (italiques ajoutés par moi):

"Thread

Public static (Partagé en Visual Basic) les membres de ce type sont thread-safe. Tous les membres de l'instance ne sont pas garantis pour être thread-safe.

Un Dictionary<(Of <(TKey, TValue>)>) peut prendre en charge plusieurs lecteurs simultanément, aussi longtemps que la collection n'est pas modifiée. De même, l'énumération d'une collection n'est pas intrinsèquement une procédure thread-safe. Dans les rares cas où une énumération soutient avec accès en écriture, la collection doit être verrouillé au cours de l'ensemble de l'énumération. Pour permettre la collecte pour être accessible par plusieurs threads pour la lecture et l'écriture, vous devez mettre en place votre propre synchronisation."

Une meilleure solution serait de créer un synchronisé dictionnaire. En voici un qui va travailler dans cette situation. Le ReaderWriterLockSlim je pense que c'est le meilleur objet de synchronisation à utiliser dans cette situation. L'écriture pour le dictionnaire est assez rare. La plupart du temps, la clé sera dans le dictionnaire. Je n'ai pas implémenter toutes les méthodes du dictionnaire, simplement celles qui ont été utilisées dans le présent cas, de sorte qu'il n'est pas encore totalement synchronisé dictionnaire.

public sealed class SynchronizedDictionary<TKey, TValue>
{
    private readonly Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>();
    private readonly ReaderWriterLockSlim readerWriterLock = new ReaderWriterLockSlim();

    public TValue this[TKey key]
    {
        get
        {
            readerWriterLock.EnterReadLock();
            try
            {
                return this.dictionary[key];
            }
            finally
            {
                readerWriterLock.ExitReadLock();
            }
        }
        set
        {
            readerWriterLock.EnterWriteLock();
            try
            {
                this.dictionary[key] = value;
            }
            finally
            {
                readerWriterLock.ExitWriteLock();
            }
        }
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        readerWriterLock.EnterReadLock();
        try
        {
            return this.dictionary.TryGetValue(key, out value);
        }
        finally
        {
            readerWriterLock.ExitReadLock();
        }
    }
}