Synchroniser Lire la collection d'écriture dans .NET

Question

J'ai un objet qui contient une collection d'éléments. Je souhaite pouvoir ajouter des éléments à la collection via une méthode AddItem et également parcourir tous les éléments de la collection. Mon objet doit être thread safe. J'utilise un ReaderWriterLockSlim pour assurer une synchronisation correcte. Comment synchroniser la méthode GoThroughAllItems? Dois-je commencer un grand ReadLock pendant toute sa durée, qui peut être très longue, ou devrais-je libérer le verrou pour chaque élément récupéré de la collection, et ré-acquérir le verrou pour le prochain?

Voici quelques exemples de code:

 
private ReaderWriterLockSlim @lock = new ReaderWriterLockSlim(); 
private List items = new List(); 

public void AddItem(Item item) 
{ 
    this.@lock.EnterWriteLock(); 

    try 
    { 
     //do something with item and add it to the collection 
     this.items.Add(item); 
    } 
    finally 
    { 
     this.@lock.ExitWriteLock(); 
    } 
} 

public void GoThroughAllItems() 
{ 
    this.@lock.EnterReadLock(); 

    try 
    { 
     foreach (Item item in this.Items) 
     { 
#if option2 
      this.@lock.ExitReadLock(); 
#endif 

      //process item, which may take a long time 

#if option2 
      this.@lock.EnterReadLock(); 
#endif 
     } 
    } 

#if option2 
    catch 
#endif 
#if option1 
    finally 
#endif 
    { 
     this.@lock.ExitReadLock(); 
    } 
} 

Answer 1

La meilleure façon est là pour créer une copie de la collecte, puis itérer dessus. Il a des frais généraux de mémoire importants (mais il sera publié peu de temps après).

Code Pseudo:

read lock 
    foreach oldColl 
     populate newColl 
exit lock 

    foreach newColl 
     do things 

et vous codez avec des serrures par article ne fonctionnera pas, parce que d'autres thread peut modifier la collecte et provoquera une erreur, car foreach ne permet pas de modification des collections.

Answer 2

Je choisirais simplement votre première option avec la région de lecture autour de la foreach puisque plusieurs threads sont autorisés dans le bloc de lecture, peu importe que ce soit plutôt lent. D'autre part, l'opération d'écriture exclusive est assez rapide. Cela devrait donc être une bonne solution.