Kolekcja została zmodyfikowana; operacja wyliczania może nie zostać wykonana

Kiedy subskrybent rezygnuje z subskrypcji, zmieniasz zawartość kolekcji subskrybentów podczas wyliczania.

Można to naprawić na kilka sposobów, jednym z nich jest zmiana pętli for na jawną .ToList():

public void NotifySubscribers(DataRecord sr)  
{
    foreach(Subscriber s in subscribers.Values.ToList())
    {
                                              ^^^^^^^^^  
        ...

Bardziej efektywnym sposobem, moim zdaniem, jest posiadanie innej listy, na której deklarujesz, że umieszczasz wszystko, co jest "do usunięcia". Następnie po zakończeniu głównej pętli (bez .ToList ()), robisz kolejną pętlę nad listą "do usunięcia", usuwając każdy wpis tak jak to się dzieje. Więc w klasie dodajesz:

private List<Guid> toBeRemoved = new List<Guid>();

Potem zmieniasz na:

public void NotifySubscribers(DataRecord sr)
{
    toBeRemoved.Clear();

    ...your unchanged code skipped...

   foreach ( Guid clientId in toBeRemoved )
   {
        try
        {
            subscribers.Remove(clientId);
        }
        catch(Exception e)
        {
            System.Diagnostics.Debug.WriteLine("Unsubscribe Error " + 
                e.Message);
        }
   }
}

...your unchanged code skipped...

public void UnsubscribeEvent(Guid clientId)
{
    toBeRemoved.Add( clientId );
}

To nie tylko rozwiąże twój problem, ale uniemożliwi ci tworzenie listy ze słownika, która jest drogie, jeśli jest tam dużo abonentów. Zakładając, że lista subskrybentów do usunięcia na danej iteracji jest niższa niż całkowita liczba na liście, powinno to być szybsze. Ale oczywiście możesz go profilować, aby upewnić się, że tak jest, jeśli masz jakiekolwiek wątpliwości dotyczące konkretnej sytuacji użytkowania.

Możesz również zablokować słownik subskrybentów, aby zapobiec jego modyfikacjom, gdy jest zapętlony:

 lock (subscribers)
 {
         foreach (var subscriber in subscribers)
         {
               //do something
         }
 }

Uwaga: ogólnie Kolekcje.Net nie wspierają jednoczesnego wyliczania i modyfikowania. Jeśli spróbujesz zmodyfikować listę kolekcji, gdy będziesz w trakcie jej wyliczania, spowoduje to powstanie wyjątek.

Problem z tym błędem polega na tym, że nie możemy modyfikować listy / słownika podczas wykonywania pętli. Jeśli jednak iterujemy słownik używając tymczasowej listy jego kluczy, równolegle możemy modyfikować obiekt dictionary, ponieważ teraz nie iterujemy słownik(i iterację jego zbioru kluczy).

Próbka:

//get key collection from dictionary into a list to loop through
List<int> keys = new List<int>(Dictionary.Keys);

// iterating key collection using simple for-each loop
foreach (int key in keys)
{
  // Now we can perform any modification with values of dictionary.
  Dictionary[key] = Dictionary[key] - 1;
}

Oto wpis na blogu o tym rozwiązaniu.

I dla głębokiego nurkowania w stackoverflow: dlaczego występuje ten błąd?

Faktycznie wydaje mi się, że problem polega na tym, że usuwasz elementy z listy i oczekujesz, że nadal będziesz czytać listę tak, jakby nic się nie stało.

To, co naprawdę musisz zrobić, to zacząć od końca i z powrotem do początku. Nawet jeśli usuniesz elementy z listy, będziesz mógł ją dalej czytać.

InvalidOperationException - Wystąpił błąd InvalidOperationException. Raportuje, że "kolekcja została zmodyfikowana" w pętli foreach-loop

Użyj instrukcji break po usunięciu obiektu.

Ex:

ArrayList list = new ArrayList(); 

foreach (var item in list)
{
    if(condition)
    {
        list.remove(item);
        break;
    }
}

Miałem ten sam problem i został rozwiązany, gdy użyłem pętli for zamiast foreach.

// foreach (var item in itemsToBeLast)
for (int i = 0; i < itemsToBeLast.Count; i++)
{
    var matchingItem = itemsToBeLast.FirstOrDefault(item => item.Detach);

   if (matchingItem != null)
   {
      itemsToBeLast.Remove(matchingItem);
      continue;
   }
   allItems.Add(itemsToBeLast[i]);// (attachDetachItem);
}

Widziałem wiele opcji na to, ale dla mnie ten był najlepszy.

ListItemCollection collection = new ListItemCollection();
        foreach (ListItem item in ListBox1.Items)
        {
            if (item.Selected)
                collection.Add(item);
        }

Następnie po prostu przełącz zbiór.

Należy pamiętać, że ListItemCollection może zawierać duplikaty. Domyślnie nic nie stoi na przeszkodzie dodaniu duplikatów do kolekcji. Aby uniknąć duplikatów można to zrobić:

ListItemCollection collection = new ListItemCollection();
            foreach (ListItem item in ListBox1.Items)
            {
                if (item.Selected && !collection.Contains(item))
                    collection.Add(item);
            }

Dobra, więc to, co mi pomogło, to iteracja do tyłu. Próbowałem usunąć wpis z listy, ale iterował w górę i zepsuł pętlę, bo wpis już nie istnieje:

for (int x = myList.Count - 1; x > -1; x--)
                        {

                            myList.RemoveAt(x);

                        }

Możesz skopiować subscribers dictionary object do tego samego typu tymczasowego obiektu słownika, a następnie iterację tymczasowego obiektu słownika za pomocą pętli foreach.

Więc innym sposobem rozwiązania tego problemu byłoby zamiast usuwania elementów utworzyć nowy słownik i dodać tylko elementy, których nie chcesz usunąć, a następnie zastąpić oryginalny słownik nowym. Nie sądzę, że jest to zbyt duży problem z wydajnością, ponieważ nie Zwiększa to liczby iteracji nad strukturą.