Welche Schleife wird in C # / VB.NET / .NET schneller ausgeführt, foroder foreach?

Seit ich vor langer Zeit gelesen habe, dass eine forSchleife schneller funktioniert als eine foreachSchleife, habe ich angenommen, dass sie für alle Sammlungen, generischen Sammlungen, alle Arrays usw. gilt.

Ich habe Google durchsucht und einige Artikel gefunden, aber die meisten sind nicht schlüssig (Kommentare zu den Artikeln lesen) und offen.

Ideal wäre es, jedes Szenario aufzulisten und die beste Lösung dafür zu finden.

Zum Beispiel (nur ein Beispiel dafür, wie es sein sollte):

1. zum Iterieren eines Arrays von mehr als 1000 Zeichenfolgen - forist besser alsforeach
2. zum Iterieren über IList(nicht generische) Zeichenfolgen - foreachist besser alsfor

Einige Referenzen im Internet für das gleiche gefunden:

1. Original großartiger alter Artikel von Emmanuel Schanzer
2. CodeProject FOREACH Vs. ZUM
3. Blog - Zu foreachoder nicht zu foreach, das ist die Frage
4. ASP.NET-Forum - NET 1.1 C # forvs.foreach

[Bearbeiten]

Abgesehen von dem Aspekt der Lesbarkeit interessiere ich mich sehr für Fakten und Zahlen. Es gibt Anwendungen, bei denen die letzte Meile der Leistungsoptimierung eine Rolle spielt.

Patrick Smacchia hat über diesen letzten Monat mit den folgenden Schlussfolgerungen gebloggt :

• for-Schleifen auf der Liste sind etwas mehr als zweimal billiger als foreach-Schleifen auf der Liste.
• Das Schleifen auf einem Array ist ungefähr zweimal billiger als das Schleifen auf einer Liste.
• Infolgedessen ist das Schleifen auf einem Array mit for fünfmal billiger als das Schleifen auf einer Liste mit foreach (was meiner Meinung nach das ist, was wir alle tun).

Zunächst eine Gegenforderung zu Dmitrys (jetzt gelöschter) Antwort . Bei Arrays gibt der C # -Compiler weitgehend denselben Code aus foreachwie bei einer äquivalenten forSchleife. Das erklärt, warum für diesen Benchmark die Ergebnisse grundsätzlich gleich sind:

using System;
using System.Diagnostics;
using System.Linq;

class Test
{
    const int Size = 1000000;
    const int Iterations = 10000;

    static void Main()
    {
        double[] data = new double[Size];
        Random rng = new Random();
        for (int i=0; i < data.Length; i++)
        {
            data[i] = rng.NextDouble();
        }

        double correctSum = data.Sum();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j=0; j < data.Length; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum-correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (int i=0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in data)
            {
                sum += d;
            }
            if (Math.Abs(sum-correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop: {0}", sw.ElapsedMilliseconds);
    }
}

Ergebnisse:

For loop: 16638
Foreach loop: 16529

Als nächstes überprüfen Sie, ob Gregs Aussage über den Sammlungstyp wichtig ist. Ändern Sie das Array in a List<double>oben, und Sie erhalten radikal unterschiedliche Ergebnisse. Es ist nicht nur im Allgemeinen erheblich langsamer, sondern foreach wird auch erheblich langsamer als der Zugriff per Index. Trotzdem würde ich foreach fast immer einer for-Schleife vorziehen, bei der der Code einfacher wird - denn Lesbarkeit ist fast immer wichtig, Mikrooptimierung dagegen selten.

foreachSchleifen zeigen eine spezifischere Absicht als forSchleifen .

Die Verwendung einer foreachSchleife zeigt jedem, der Ihren Code verwendet, dass Sie vorhaben, jedem Mitglied einer Sammlung etwas anzutun, unabhängig von seinem Platz in der Sammlung. Es zeigt auch, dass Sie die ursprüngliche Sammlung nicht ändern (und löst eine Ausnahme aus, wenn Sie dies versuchen).

Der andere Vorteil von foreachist, dass es auf jedem funktioniert IEnumerable, wo es fornur Sinn macht IList, wo jedes Element tatsächlich einen Index hat.

Wenn Sie jedoch den Index eines Elements verwenden müssen, sollten Sie natürlich eine forSchleife verwenden dürfen. Wenn Sie jedoch keinen Index verwenden müssen, ist es nur unübersichtlich, wenn Sie einen Index haben.

Soweit mir bekannt ist, gibt es keine wesentlichen Auswirkungen auf die Leistung. Irgendwann in der Zukunft ist es möglicherweise einfacher, Code so anzupassen, dass foreacher auf mehreren Kernen ausgeführt wird, aber das ist im Moment kein Grund zur Sorge.

Jedes Mal, wenn es Streitigkeiten über die Leistung gibt, müssen Sie nur einen kleinen Test schreiben, damit Sie quantitative Ergebnisse verwenden können, um Ihren Fall zu unterstützen.

Verwenden Sie die StopWatch-Klasse und wiederholen Sie aus Gründen der Genauigkeit einige Millionen Mal. (Dies könnte ohne eine for-Schleife schwierig sein):

using System.Diagnostics;
//...
Stopwatch sw = new Stopwatch()
sw.Start()
for(int i = 0; i < 1000000;i ++)
{
    //do whatever it is you need to time
}
sw.Stop();
//print out sw.ElapsedMilliseconds

Die Daumen drücken, um zu zeigen, dass der Unterschied vernachlässigbar ist, und Sie können genauso gut alles tun, was zu dem am besten zu wartenden Code führt

Es wird immer nah sein. Bei einem Array ist es manchmal for etwas schneller, aber foreachausdrucksstärker und bietet LINQ usw. Im Allgemeinen bleiben Sie bei foreach.

foreachKann in einigen Szenarien zusätzlich optimiert werden. Zum Beispiel kann eine verknüpfte Liste für den Indexer schrecklich sein, aber sie kann schnell vorbei sein foreach. Tatsächlich bietet der Standard LinkedList<T>aus diesem Grund nicht einmal einen Indexer an.

Ich vermute, dass es in 99% der Fälle wahrscheinlich nicht signifikant sein wird. Warum sollten Sie also die schnellere anstelle der am besten geeigneten wählen (wie am einfachsten zu verstehen / zu pflegen)?

Es ist unwahrscheinlich, dass zwischen beiden ein großer Leistungsunterschied besteht. Wie immer, wenn man mit einem "Was ist schneller?" Frage, sollten Sie immer denken "Ich kann das messen."

Schreiben Sie zwei Schleifen, die dasselbe tun, in den Körper der Schleife, führen Sie beide aus und messen Sie sie zeitlich, und sehen Sie, was der Geschwindigkeitsunterschied ist. Tun Sie dies sowohl mit einem fast leeren Körper als auch mit einem Schleifenkörper, ähnlich dem, was Sie tatsächlich tun werden. Versuchen Sie es auch mit dem von Ihnen verwendeten Sammlungstyp, da verschiedene Arten von Sammlungen unterschiedliche Leistungsmerkmale aufweisen können.

Es gibt sehr gute Gründe, Loops Loops vorzuziehen . Wenn Sie eine Schleife verwenden können, hat Ihr Chef Recht, dass Sie sollten.foreachforforeach

Allerdings durchläuft nicht jede Iteration einfach eine Liste nacheinander. Wenn er es verbietet , ist das falsch.

Wenn ich Sie wäre, würde ich all Ihre natürlichen for-Schleifen in Rekursion verwandeln . Das würde ihn lehren, und es ist auch eine gute mentale Übung für dich.

Jeffrey Richter auf TechEd 2005:

"Ich habe im Laufe der Jahre gelernt, dass der C # -Compiler für mich im Grunde genommen ein Lügner ist." .. "Es liegt an vielen Dingen." .. "Wie wenn Sie eine foreach-Schleife ausführen ..." .. "... das ist eine kleine Codezeile, die Sie schreiben, aber was der C # -Compiler ausspuckt, um dies zu tun, ist phänomenal try / finally-Block dort, innerhalb des finally-Blocks wird Ihre Variable in eine IDisposable-Schnittstelle umgewandelt, und wenn die Umwandlung erfolgreich ist, ruft sie die Dispose-Methode auf, innerhalb der Schleife werden die Current-Eigenschaft und die MoveNext-Methode wiederholt innerhalb der Schleife aufgerufen. Objekte werden unter der Decke erstellt. Viele Leute verwenden foreach, weil es sehr einfach zu codieren ist, sehr einfach zu machen. ".." foreach ist nicht sehr gut in Bezug auf die Leistung.

On-Demand-Webcast: http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032292286&EventCategory=3&culture=en-US&CountryCode=US

Das ist lächerlich. Es gibt keinen zwingenden Grund, die for-Schleife in Bezug auf die Leistung oder andere zu verbieten.

In Jon Skeets Blog finden Sie einen Leistungsbenchmark und andere Argumente.

In Fällen, in denen Sie mit einer Sammlung von Objekten arbeiten, foreachist dies besser. Wenn Sie jedoch eine Zahl erhöhen, ist eine forSchleife besser.

Beachten Sie, dass Sie im letzten Fall Folgendes tun können:

foreach (int i in Enumerable.Range(1, 10))...

Aber es ist sicherlich nicht besser, es hat tatsächlich eine schlechtere Leistung als ein for.

Dies sollte Sie retten:

public IEnumerator<int> For(int start, int end, int step) {
    int n = start;
    while (n <= end) {
        yield n;
        n += step;
    }
}

Verwenden:

foreach (int n in For(1, 200, 4)) {
    Console.WriteLine(n);
}

Für einen größeren Gewinn können Sie drei Delegierte als Parameter verwenden.

Sie können darüber in Deep .NET - Teil 1 Iteration lesen

Es deckt die Ergebnisse (ohne die erste Initialisierung) vom .NET-Quellcode bis zur Demontage ab.

Beispiel: Array-Iteration mit einer foreach-Schleife:

und - Iteration mit foreach-Schleife auflisten:

und das Endergebnis:

Die Geschwindigkeitsunterschiede in einer for- und einer - foreachSchleife sind winzig, wenn Sie allgemeine Strukturen wie Arrays, Listen usw. durchlaufen und a ausführenLINQ Abfrage über die Sammlung fast immer etwas langsamer durchführen, obwohl das Schreiben besser ist! Wie die anderen Poster bereits sagten, sollten Sie sich eher für Ausdruckskraft als für eine Millisekunde zusätzliche Leistung entscheiden.

Was bisher nicht gesagt wurde, ist, dass eine foreachSchleife beim Kompilieren vom Compiler basierend auf der Sammlung optimiert wird, über die sie iteriert. Das heißt, wenn Sie nicht sicher sind, welche Schleife Sie verwenden sollen, sollten Sie die foreachSchleife verwenden - sie generiert die beste Schleife für Sie, wenn sie kompiliert wird. Es ist auch besser lesbar.

Ein weiterer wichtiger Vorteil der foreachSchleife besteht darin, dass bei Änderungen Ihrer Sammlungsimplementierung ( z. B. von int arrayzu a) List<int>für Ihre foreachSchleife keine Codeänderungen erforderlich sind:

foreach (int i in myCollection)

Das Obige ist unabhängig vom Typ Ihrer Sammlung gleich, während in Ihrer forSchleife Folgendes nicht erstellt wird, wenn Sie myCollectionvon a arrayzu a wechseln List:

for (int i = 0; i < myCollection.Length, i++)

"Gibt es Argumente, mit denen ich ihn davon überzeugen könnte, dass die for-Schleife akzeptabel ist?"

Nein, wenn Ihr Chef so viel Mikromanagement betreibt, dass er Ihnen sagt, welche Programmiersprachenkonstrukte verwendet werden sollen, können Sie wirklich nichts sagen. Es tut uns leid.

Dies hängt wahrscheinlich von der Art der Auflistung ab, die Sie auflisten, und von der Implementierung des Indexers. Im Allgemeinen ist die Verwendung foreachwahrscheinlich ein besserer Ansatz.

Es wird auch mit jedem funktionieren IEnumerable- nicht nur mit Indexern.

Dies hat die gleichen zwei Antworten wie die meisten "was schneller ist" -Fragen:

1) Wenn Sie nicht messen, wissen Sie es nicht.

2) (Weil ...) Es kommt darauf an.

Dies hängt davon ab, wie teuer die Methode "MoveNext ()" ist, im Vergleich dazu, wie teuer die Methode "this [int index]" für den Typ (oder die Typen) von IEnumerable ist, über den Sie iterieren werden.

Das Schlüsselwort "foreach" ist eine Abkürzung für eine Reihe von Operationen - es ruft GetEnumerator () einmal in der IEnumerable auf, es ruft MoveNext () einmal pro Iteration auf, es führt eine Typprüfung durch und so weiter. Die Kosten für MoveNext () wirken sich am wahrscheinlichsten auf die Leistungsmessungen aus, da diese O (N) Mal aufgerufen werden. Vielleicht ist es billig, aber vielleicht nicht.

Das Schlüsselwort "for" sieht vorhersehbarer aus, aber in den meisten "for" -Schleifen finden Sie so etwas wie "collection [index]". Dies sieht aus wie eine einfache Array-Indizierungsoperation, ist jedoch ein Methodenaufruf, dessen Kosten vollständig von der Art der Sammlung abhängen, über die Sie iterieren. Wahrscheinlich ist es billig, aber vielleicht nicht.

Wenn die zugrunde liegende Struktur der Sammlung im Wesentlichen eine verknüpfte Liste ist, ist MoveNext spottbillig, aber der Indexer hat möglicherweise O (N) -Kosten, wodurch die tatsächlichen Kosten einer "for" -Schleife O (N * N) entstehen.

Jedes Sprachkonstrukt hat eine geeignete Zeit und einen geeigneten Ort für die Verwendung. Es gibt einen Grund, warum die C # -Sprache vier separate Iterationsanweisungen hat - jede ist für einen bestimmten Zweck da und hat eine angemessene Verwendung.

Ich empfehle, sich mit Ihrem Chef zusammenzusetzen und rational zu erklären, warum eine forSchleife einen Zweck hat. Es gibt Zeiten, in denen ein forIterationsblock einen Algorithmus klarer beschreibt als eine foreachIteration. Wenn dies zutrifft, ist es angebracht, sie zu verwenden.

Ich möchte auch Ihren Chef darauf hinweisen - Leistung ist kein Problem und sollte in keiner praktischen Weise ein Problem sein - es geht eher darum, den Algorithmus auf prägnante, aussagekräftige und wartbare Weise auszudrücken. Mikrooptimierungen wie diese verfehlen den Punkt der Leistungsoptimierung vollständig, da jeder echte Leistungsvorteil durch algorithmisches Redesign und Refactoring und nicht durch Loop-Restrukturierung erzielt wird.

Wenn es nach einer rationalen Diskussion immer noch diese autoritäre Sichtweise gibt, liegt es an Ihnen, wie Sie vorgehen sollen. Persönlich würde ich nicht gerne in einem Umfeld arbeiten, in dem rationales Denken entmutigt wird, und würde in Betracht ziehen, bei einem anderen Arbeitgeber in eine andere Position zu wechseln. Ich empfehle jedoch dringend, die Diskussion zu führen, bevor Sie sich aufregen - möglicherweise liegt nur ein einfaches Missverständnis vor.

Es ist das, was Sie innerhalb der Schleife tun, das die Leistung beeinflusst, nicht das eigentliche Schleifenkonstrukt (vorausgesetzt, Ihr Fall ist nicht trivial).

Ob forist schneller alsforeach wirklich nebensächlich. Ich bezweifle ernsthaft, dass die Auswahl eines über das andere einen erheblichen Einfluss auf Ihre Leistung hat.

Der beste Weg, um Ihre Anwendung zu optimieren, ist die Profilerstellung des tatsächlichen Codes. Dadurch werden die Methoden ermittelt, die die meiste Arbeit / Zeit ausmachen. Optimieren Sie diese zuerst. Wenn die Leistung immer noch nicht akzeptabel ist, wiederholen Sie den Vorgang.

Generell würde ich empfehlen, sich von Mikrooptimierungen fernzuhalten, da diese selten zu signifikanten Gewinnen führen. Die einzige Ausnahme ist die Optimierung identifizierter Hot-Paths (dh wenn Ihre Profilerstellung einige häufig verwendete Methoden identifiziert, kann es sinnvoll sein, diese umfassend zu optimieren).

Die beiden laufen fast genauso. Schreiben Sie einen Code, um beide zu verwenden, und zeigen Sie ihm dann die IL. Es sollte vergleichbare Berechnungen anzeigen, dh keinen Leistungsunterschied.

for hat eine einfachere Logik zu implementieren, so dass es schneller als foreach ist.

Wenn Sie sich nicht in einem bestimmten Prozess zur Geschwindigkeitsoptimierung befinden, würde ich sagen, verwenden Sie die Methode, die den am einfachsten zu lesenden und zu pflegenden Code erzeugt.

Wenn bereits ein Iterator eingerichtet ist, wie bei einer der Auflistungsklassen, ist foreach eine gute und einfache Option. Und wenn es sich um einen ganzzahligen Bereich handelt, den Sie iterieren, ist for wahrscheinlich sauberer.

Jeffrey Richter sprach kürzlich in einem Podcast über den Leistungsunterschied zwischen for und foreach: http://pixel8.infragistics.com/shows/everything.aspx#Episode:9317

In den meisten Fällen gibt es wirklich keinen Unterschied.

Normalerweise müssen Sie foreach immer verwenden, wenn Sie keinen expliziten numerischen Index haben, und Sie müssen immer foreach verwenden, wenn Sie keine iterierbare Sammlung haben (z. B. Iteration über ein zweidimensionales Array-Gitter in einem oberen Dreieck). . In einigen Fällen haben Sie die Wahl.

Man könnte argumentieren, dass es etwas schwieriger sein kann, for-Schleifen zu pflegen, wenn magische Zahlen im Code erscheinen. Sie sollten sich zu Recht darüber ärgern, dass Sie keine for-Schleife verwenden können und stattdessen eine Sammlung oder ein Lambda verwenden müssen, um eine Untersammlung zu erstellen, nur weil for-Schleifen verboten wurden.

Es scheint ein bisschen seltsam, die Verwendung einer for-Schleife völlig zu verbieten.

Es ist ein interessanter Artikel hier , die eine Menge der Leistungsunterschiede zwischen den beiden Schleifen abdeckt.

Ich persönlich würde sagen, dass foreach für Schleifen etwas besser lesbar ist, aber Sie sollten das Beste für den jeweiligen Job verwenden und keinen extra langen Code schreiben müssen, um eine foreach-Schleife einzuschließen, wenn eine for-Schleife besser geeignet ist.

Ich fand die foreachSchleife, die List schneller durchlief . Siehe meine Testergebnisse unten. Im folgenden Code iteriere ich eine arrayGröße der Größen 100, 10000 und 100000 separat mit forund foreachloop, um die Zeit zu messen.

private static void MeasureTime()
    {
        var array = new int[10000];
        var list = array.ToList();
        Console.WriteLine("Array size: {0}", array.Length);

        Console.WriteLine("Array For loop ......");
        var stopWatch = Stopwatch.StartNew();
        for (int i = 0; i < array.Length; i++)
        {
            Thread.Sleep(1);
        }
        stopWatch.Stop();
        Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("Array Foreach loop ......");
        var stopWatch1 = Stopwatch.StartNew();
        foreach (var item in array)
        {
            Thread.Sleep(1);
        }
        stopWatch1.Stop();
        Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch1.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("List For loop ......");
        var stopWatch2 = Stopwatch.StartNew();
        for (int i = 0; i < list.Count; i++)
        {
            Thread.Sleep(1);
        }
        stopWatch2.Stop();
        Console.WriteLine("Time take to run the for loop is {0} millisecond", stopWatch2.ElapsedMilliseconds);

        Console.WriteLine(" ");
        Console.WriteLine("List Foreach loop ......");
        var stopWatch3 = Stopwatch.StartNew();
        foreach (var item in list)
        {
            Thread.Sleep(1);
        }
        stopWatch3.Stop();
        Console.WriteLine("Time take to run the foreach loop is {0} millisecond", stopWatch3.ElapsedMilliseconds);
    }

AKTUALISIERT

Nach dem @ jgauffin-Vorschlag habe ich den @ johnskeet-Code verwendet und festgestellt, dass die forSchleife mit arrayschneller ist als die folgende.

• Foreach-Schleife mit Array.
• For-Schleife mit Liste.
• Foreach-Schleife mit Liste.

Siehe meine Testergebnisse und Code unten,

private static void MeasureNewTime()
    {
        var data = new double[Size];
        var rng = new Random();
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = rng.NextDouble();
        }
        Console.WriteLine("Lenght of array: {0}", data.Length);
        Console.WriteLine("No. of iteration: {0}", Iterations);
        Console.WriteLine(" ");
        double correctSum = data.Sum();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j = 0; j < data.Length; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop with Array: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (var i = 0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in data)
            {
                sum += d;
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop with Array: {0}", sw.ElapsedMilliseconds);
        Console.WriteLine(" ");

        var dataList = data.ToList();
        sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            for (int j = 0; j < dataList.Count; j++)
            {
                sum += data[j];
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("For loop with List: {0}", sw.ElapsedMilliseconds);

        sw = Stopwatch.StartNew();
        for (int i = 0; i < Iterations; i++)
        {
            double sum = 0;
            foreach (double d in dataList)
            {
                sum += d;
            }
            if (Math.Abs(sum - correctSum) > 0.1)
            {
                Console.WriteLine("Summation failed");
                return;
            }
        }
        sw.Stop();
        Console.WriteLine("Foreach loop with List: {0}", sw.ElapsedMilliseconds);
    }

Sie können wirklich mit seinem Kopf schrauben und stattdessen einen IQueryable .foreach-Verschluss anstreben:

myList.ForEach(c => Console.WriteLine(c.ToString());

Ich würde nicht erwarten, dass jemand einen "großen" Leistungsunterschied zwischen den beiden findet.

Ich denke, die Antwort hängt davon ab, ob die Sammlung, auf die Sie zugreifen möchten, eine schnellere Implementierung des Indexerzugriffs oder eine schnellere Implementierung des IEnumerator-Zugriffs aufweist. Da IEnumerator häufig den Indexer verwendet und nur eine Kopie der aktuellen Indexposition enthält, würde ich erwarten, dass der Enumeratorzugriff mindestens so langsam oder langsamer ist als der direkte Indexzugriff, jedoch nicht viel.

Natürlich berücksichtigt diese Antwort keine Optimierungen, die der Compiler möglicherweise implementiert.

Beachten Sie, dass die for-Schleife und die foreach-Schleife nicht immer gleichwertig sind. Listenaufzähler lösen eine Ausnahme aus, wenn sich die Liste ändert, aber Sie erhalten diese Warnung nicht immer mit einer normalen for-Schleife. Möglicherweise erhalten Sie sogar eine andere Ausnahme, wenn sich die Liste zum falschen Zeitpunkt ändert.