Seltsam, "die Auflistung wurde geändert, nachdem der enumerator instanziiert wurde" Ausnahme

Vielleicht jemand kann mich in die richtige Richtung, da bin ich völlig überfragt.

Ich habe eine Funktion, die einfach druckt eine LinkedList Klassen:

    LinkedList<Component> components = new LinkedList<Component>();
    ...
    private void PrintComponentList()
    {
        Console.WriteLine("---Component List: " + components.Count + " entries---");
        foreach (Component c in components)
        {
            Console.WriteLine(c);
        }
        Console.WriteLine("------");
    }

Den Component Objekt tatsächlich hat Sie eine benutzerdefinierte ToString() nennen als solche:

    int Id;
    ...
    public override String ToString()
    {
        return GetType() + ": " + Id;
    }

Diese Funktion in der Regel gut funktioniert - aber ich habe, laufen in das Problem, dass, wenn es baut auf über 30 oder so Einträge in der Liste, die PrintcomplentList foreach Aussage kommt zurück mit einer InvalidOperationException: Collection was modified after the enumerator was instantiated.

Nun, wie Sie sehen können, dass ich mich nicht ändern Sie den code innerhalb der for-Schleife, und ich habe nicht explizit erstellt threads, obwohl dies innerhalb eines XNA-Umgebung (falls es darauf ankommt). Es sollte angemerkt werden, dass der Ausdruck ist Häufig genug, dass die Ausgabe in der Konsole verlangsamt das Programm als ganzes.

Ich bin völlig ratlos, hat jemand dort draussen in dieser?

Das klingt extrem seltsam. Könnte Sie post ein kurzes, aber komplett - Programm, damit wir versuchen können, um es zu reproduzieren?
Ich werde sehen, was ich tun kann.
Ich cna nicht bekommen ein kleines Programm zu replizieren, die Verhalten, so werde ich sehen, darum ein thread-sichere Implementierung der LinkedList in dort zu sehen, ob es fängt alles

InformationsquelleAutor cyberconte | 2009-05-10

c#enumeration

10

Ich vermute, dass der Ort zu Beginn der Suche wird an jedem Orte, wo Sie manipulieren die Liste - d.h. insert/remove/re-Positionen zuordnen. Mein Verdacht ist, dass es eine Rückruf - /selbst-handler das ist irgendwo gefeuert asynchron (vielleicht als Teil des XNA Farbe etc Schleifen), und die Bearbeitung der Liste - im wesentlichen verursacht dieses problem, da eine race-Bedingung.

Überprüfen, ob dies der Fall ist, setzen einige debug - /trace-Ausgabe rund um die Orte zu manipulieren, dass die Liste, und sehen, ob es überhaupt (und insbesondere kurz vor die Ausnahme ist) läuft die manipulation von code zur gleichen Zeit wie Ihr die Ausgabe der Konsole:
```
private void SomeCallback()
{
   Console.WriteLine("---Adding foo"); //temp investigation code; remove
   components.AddLast(foo);
   Console.WriteLine("---Added foo"); //temp investigation code; remove
}
```
Leider, solche Dinge sind oft schwer zu Debuggen, da sich der code, es zu untersuchen, ändert sich oft das problem (ein Heisenbug).

Einer Antwort wäre zu synchronisieren, Zugang, d.h. in alle die Orte, die die Liste Bearbeiten, verwenden Sie eine lock um den kompletten Betrieb:
```
LinkedList<Component> components = new LinkedList<Component>();
readonly object syncLock = new object();
...
private void PrintComponentList()
{
    lock(syncLock)
    { //take lock before first use (.Count), covering the foreach
        Console.WriteLine("---Component List: " + components.Count
              + " entries---");
        foreach (Component c in components)
        {
           Console.WriteLine(c);
        }
        Console.WriteLine("------");
    } //release lock
}
```
und in deinem callback (oder was auch immer)
```
private void SomeCallback()
{
   lock(syncLock)
   {
       components.AddLast(foo);
   }
}
```
Insbesondere eine "komplette" zählen könnte:
- überprüfen Sie die Anzahl und foreach/for
- überprüfen Sie für existance und einfügen/entfernen
- etc
(also nicht die einzelne/diskrete Operationen - aber Arbeitseinheiten)

beachten Sie auch, dass die Protokollierung der thread-id, wenn Sie schreiben, Ihre trace-Linien kann helfen, Sie zu identifizieren, wenn es konkurrierende threads, und damit die Möglichkeit, in einem Rennen.

InformationsquelleAutor Marc Gravell
4

Statt foreach verwende ich while( collection.count >0) dann verwenden collection[i].

InformationsquelleAutor arash
2

Ich weiß nicht, ob dies relevant ist für die OP, aber ich hatte den gleichen Fehler und fand diesen thread bei einer google-Suche. Ich war in der Lage, es zu lösen, indem Sie hinzufügen einer Pause nach dem entfernen Sie ein element in der Schleife.
```
foreach( Weapon activeWeapon in activeWeapons ){

            if (activeWeapon.position.Z < activeWeapon.range)
            {
                activeWeapons.Remove(activeWeapon);
                break; //Fixes error
            }
            else
            {
                activeWeapon.position += activeWeapon.velocity;
            }
        }
    }
```
Wenn man die Pause machen, werden Sie die Fehlermeldung erhalten: "InvalidOperationException: die Auflistung wurde geändert, nachdem der enumerator instanziiert wurde."

Dies führt zu einem Fehler, wenn -- eine eurer Waffen in der Liste nach dem ersten out-of-range-Waffe nicht haben Ihre Positionen geändert! Ich behandelt haben dies in der Vergangenheit durch erstellen einer zweiten Liste von Sachen, die zu entfernen Sie aus der ersten Liste aus und füllt es in eine foreach-Schleife, dann tut ein foreach über die zweite Liste, und entfernen Sie jedes Element aus der ersten Liste.

InformationsquelleAutor Steffan
0

Mit Break ein Weg sein könnte, aber es kann Auswirkungen auf eine Reihe von der operation.
Was ich in diesem Fall einfach konvertieren Sie die foreach traditionellen for Schleife
```
for(i=0; i < List.count; i++)
{
    List.Remove();
    i--;
}
```
Dieses funktioniert ohne Probleme.

Das könnte funktionieren, aber in diesem Fall wird die iteration über die Objekte einer Sammlung. foreach(var obj in der Sammlung.Schlüssel)...

InformationsquelleAutor Saikat Chakraborty

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.