Welche Schleife in .NET läuft schneller, "for" oder "foreach"?

Question

In C#/VB.NET/.NET, welche Schleife läuft schneller, for o foreach ?

Seitdem ich gelesen habe, dass ein for Schleife arbeitet schneller als eine foreach Schleife a vor langer Zeit Ich nahm an, dass dies für alle Sammlungen, generischen Sammlungen, alle Arrays usw. gilt.

Ich habe Google durchforstet und einige Artikel gefunden, aber die meisten davon sind nicht schlüssig (lesen Sie die Kommentare zu den Artikeln) und haben ein offenes Ende.

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

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

1. für die Iteration eines Arrays von 1000+ Zeichenketten - for ist besser als foreach
2. zur Iteration über IList (nicht generische) Zeichenketten - foreach ist besser als for

Ein paar Referenzen im Internet für das gleiche gefunden:

1. Ursprünglicher großer alter Artikel von Emmanuel Schanzer
2. CodeProject FOREACH Vs. FOR
3. Blog - Zum foreach oder nicht foreach das ist die Frage
4. ASP.NET Forum - NET 1.1 C# for vs foreach

[Bearbeiten]

Abgesehen vom Aspekt der Lesbarkeit bin ich wirklich an Fakten und Zahlen interessiert. Es gibt Anwendungen, bei denen es auf die letzte Meile der Leistungsoptimierung ankommt.

Answer 1

Wenn Sie nicht gerade an einer speziellen Geschwindigkeitsoptimierung arbeiten, würde ich sagen, dass Sie die Methode verwenden sollten, die den am einfachsten zu lesenden und zu wartenden Code ergibt.

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

Answer 2

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

Answer 3

Ich habe es vor einiger Zeit getestet, mit dem Ergebnis, dass ein for Schleife ist viel schneller als eine foreach Schleife. Die Ursache ist einfach, die foreach Schleife muss zunächst eine Instanz der IEnumerator für die Sammlung.

Answer 4

Ich fand die foreach Schleife, die sich durch eine List schneller . Siehe meine Testergebnisse unten. Im folgenden Code iteriere ich eine array der Größe 100, 10000 und 100000 getrennt mit for y foreach Schleife, 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 Vorschlag von @jgauffin habe ich den Code von @johnskeet verwendet und festgestellt, dass die for Schleife mit array ist schneller als das Verfolgen,

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

Siehe meine Testergebnisse und den 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);
    }

Answer 5

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 bei einer normalen for-Schleife erhalten Sie diese Warnung nicht immer. Sie können sogar eine andere Ausnahme erhalten, wenn sich die Liste genau zum falschen Zeitpunkt ändert.