En C # / VB.NET / .NET, ¿qué ciclo se ejecuta más rápido foro foreach?

Desde que leí que un forbucle funciona más rápido que un foreachbucle hace mucho tiempo, supuse que era cierto para todas las colecciones, colecciones genéricas, todas las matrices, etc.

Recorrí Google y encontré algunos artículos, pero la mayoría de ellos no son concluyentes (lea los comentarios sobre los artículos) y están abiertos.

Lo ideal sería tener cada escenario en la lista y la mejor solución para el mismo.

Por ejemplo (solo un ejemplo de cómo debería ser):

1. para iterar una matriz de más de 1000 cadenas, fores mejor queforeach
2. para iterar sobre IListcadenas (no genéricas): foreaches mejor quefor

Algunas referencias encontradas en la web para lo mismo:

1. Gran artículo original de Emmanuel Schanzer
2. CodeProject FOREACH Vs. PARA
3. Blog: para foreacho no foreach, esa es la pregunta
4. Foro ASP.NET - NET 1.1 C # forvsforeach

[Editar]

Además del aspecto de legibilidad, estoy realmente interesado en hechos y cifras. Hay aplicaciones en las que importa la última milla de optimización de rendimiento.

Patrick Smacchia escribió en su blog sobre este último mes, con las siguientes conclusiones:

• Los bucles for List son un poco más de 2 veces más baratos que los bucles foreach en List.
• El bucle en la matriz es aproximadamente 2 veces más barato que el bucle en Lista
• Como consecuencia, el bucle en la matriz usando for es 5 veces más barato que el bucle en la lista usando foreach (que creo que es lo que todos hacemos).

Primero, una contrademanda a la respuesta de Dmitry (ahora eliminada) . Para las matrices, el compilador de C # emite en gran medida el mismo código foreachque para un forbucle equivalente . Eso explica por qué para este punto de referencia, los resultados son básicamente los mismos:

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);
    }
}

Resultados:

For loop: 16638
Foreach loop: 16529

Luego, valide que el punto de Greg sobre el tipo de colección es importante: cambie la matriz a a List<double>en lo anterior y obtendrá resultados radicalmente diferentes. No solo es significativamente más lento en general, sino que foreach se vuelve significativamente más lento que acceder por índice. Dicho esto, todavía preferiría casi siempre foreach a un bucle for donde simplifica el código, porque la legibilidad es casi siempre importante, mientras que la micro-optimización rara vez lo es.

foreachlos bucles demuestran una intención más específica que los forbucles .

El uso de un foreachbucle demuestra a cualquiera que use su código que planea hacer algo a cada miembro de una colección, independientemente de su lugar en la colección. También muestra que no está modificando la colección original (y lanza una excepción si lo intenta).

La otra ventaja foreaches que funciona en cualquiera IEnumerable, donde forsolo tiene sentido IList, donde cada elemento tiene un índice.

Sin embargo, si necesita usar el índice de un elemento, entonces, por supuesto, debería poder usar un forbucle. Pero si no necesita usar un índice, tener uno es simplemente abarrotar su código.

No hay implicaciones significativas de rendimiento hasta donde yo sé. En algún momento en el futuro, podría ser más fácil adaptar el código foreachpara ejecutar en múltiples núcleos, pero eso no es algo de qué preocuparse en este momento.

Cada vez que hay argumentos sobre el rendimiento, solo necesita escribir una pequeña prueba para que pueda usar resultados cuantitativos para respaldar su caso.

Use la clase StopWatch y repita algo unos millones de veces, para mayor precisión. (Esto podría ser difícil sin un bucle for):

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

Los dedos cruzaron los resultados de este programa que muestran que la diferencia es insignificante, y que bien podría hacer lo que resulte en el código más fácil de mantener

Siempre estará cerca. Para una matriz, a veces for es un poco más rápido, pero foreaches más expresivo y ofrece LINQ, etc. En general, quédese con foreach.

Además, foreachpuede optimizarse en algunos escenarios. Por ejemplo, una lista vinculada puede ser terrible por indexador, pero puede ser rápida por foreach. En realidad, el estándar LinkedList<T>ni siquiera ofrece un indexador por este motivo.

Supongo que probablemente no será significativo en el 99% de los casos, entonces, ¿por qué elegiría el más rápido en lugar del más apropiado (como el más fácil de entender / mantener)?

Es poco probable que haya una gran diferencia de rendimiento entre los dos. Como siempre, cuando nos enfrentamos a un "¿cuál es más rápido?" pregunta, siempre debes pensar "puedo medir esto".

Escriba dos bucles que hagan lo mismo en el cuerpo del bucle, ejecute y cronometre ambos, y vea cuál es la diferencia en velocidad. Haga esto con un cuerpo casi vacío y un cuerpo de bucle similar a lo que realmente hará. También pruébelo con el tipo de colección que está utilizando, porque los diferentes tipos de colecciones pueden tener diferentes características de rendimiento.

Hay muy buenas razones para preferir foreach bucles sobre forbucles. Si puede usar un foreachbucle, su jefe tiene razón en que debería hacerlo.

Sin embargo, no todas las iteraciones simplemente pasan por una lista en orden una por una. Si él está prohibiendo , sí, eso está mal.

Si yo fuera tú, lo que haría sería convertir todos tus bucles naturales en recursividad . Eso le enseñaría, y también es un buen ejercicio mental para ti.

Jeffrey Richter en TechEd 2005:

"He aprendido a lo largo de los años que el compilador de C # es básicamente un mentiroso para mí". .. "Miente sobre muchas cosas". .. "Como cuando haces un bucle foreach ..." ... "... esa es una pequeña línea de código que escribes, pero lo que escupe el compilador de C # para hacer eso es fenomenal. intente / finalmente bloquee allí, dentro del bloque finalmente, convierte su variable en una interfaz IDisposable, y si la conversión tiene éxito, llama al método Dispose, dentro del ciclo llama a la propiedad Current y al método MoveNext repetidamente dentro del ciclo, se están creando objetos debajo de las cubiertas. Mucha gente usa foreach porque es una codificación muy fácil, muy fácil de hacer ... "..." foreach no es muy bueno en términos de rendimiento,

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

Esto es ridículo. No hay una razón convincente para prohibir el for-loop, el rendimiento inteligente u otro.

Vea el blog de Jon Skeet para un punto de referencia de rendimiento y otros argumentos.

En los casos en que trabaja con una colección de objetos, foreaches mejor, pero si incrementa un número, un forbucle es mejor.

Tenga en cuenta que en el último caso, podría hacer algo como:

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

Pero ciertamente no funciona mejor, en realidad tiene un rendimiento peor en comparación con a for.

Esto debería salvarte:

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

Utilizar:

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

Para una mayor victoria, puede tomar tres delegados como parámetros.

puedes leer sobre esto en Deep .NET - parte 1 Iteración

cubre los resultados (sin la primera inicialización) desde el código fuente de .NET hasta el desmontaje.

por ejemplo: iteración de matriz con un bucle foreach:

y - enumerar iteración con foreach loop:

y los resultados finales:

Las diferencias de velocidad en a for- y a - foreachloop son muy pequeñas cuando recorres estructuras comunes como matrices, listas, etc., y hacer una LINQconsulta sobre la colección es casi siempre un poco más lento, ¡aunque es mejor escribir! Como decían los otros carteles, busque expresividad en lugar de un milisegundo de rendimiento adicional.

Lo que no se ha dicho hasta ahora es que cuando foreachse compila un bucle, el compilador lo optimiza en función de la colección sobre la que está iterando. Eso significa que cuando no esté seguro de qué bucle usar, debe usar el foreachbucle: generará el mejor bucle para usted cuando se compile. También es más legible.

Otra ventaja clave con el foreachbucle es que si la implementación de su colección cambia (de un int arraya un, List<int>por ejemplo), entonces su foreachbucle no requerirá ningún cambio de código:

foreach (int i in myCollection)

Lo anterior es el mismo sin importar de qué tipo sea su colección, mientras que en su forciclo, lo siguiente no se compilará si cambia myCollectionde arraya a List:

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

"¿Hay algún argumento que pueda usar para ayudarme a convencerlo de que el bucle for es aceptable?"

No, si tu jefe está microgestionando hasta el nivel de decirte qué construcciones de lenguaje de programación usar, realmente no hay nada que puedas decir. Lo siento.

Probablemente depende del tipo de colección que esté enumerando y la implementación de su indexador. Sin embargo, en general, foreaches probable que el uso sea un mejor enfoque.

Además, funcionará con cualquiera IEnumerable, no solo con indexadores.

Tiene las mismas dos respuestas que la mayoría de las preguntas "que es más rápido":

1) Si no mides, no lo sabes.

2) (Porque ...) Depende.

Depende de cuán costoso sea el método "MoveNext ()", en relación con lo costoso que es el método "this [int index]", para el tipo (o tipos) de IEnumerable sobre el que iterará.

La palabra clave "foreach" es la abreviatura de una serie de operaciones: llama a GetEnumerator () una vez en IEnumerable, llama a MoveNext () una vez por iteración, realiza algunas comprobaciones de tipo, etc. Lo más probable para impactar las mediciones de rendimiento es el costo de MoveNext () ya que se invoca O (N) veces. Quizás sea barato, pero quizás no lo sea.

La palabra clave "for" parece más predecible, pero dentro de la mayoría de los bucles "for" encontrará algo así como "colección [índice]". Esto parece una simple operación de indexación de matriz, pero en realidad es una llamada a un método, cuyo costo depende completamente de la naturaleza de la colección sobre la que está iterando. Probablemente sea barato, pero tal vez no lo sea.

Si la estructura subyacente de la colección es esencialmente una lista vinculada, MoveNext es muy barato, pero el indexador puede tener un costo O (N), lo que hace que el costo real de un bucle "for" O (N * N).

Cada construcción de lenguaje tiene un momento y lugar apropiados para su uso. Hay una razón por la cual el lenguaje C # tiene cuatro declaraciones de iteración separadas : cada una está ahí para un propósito específico y tiene un uso apropiado.

Recomiendo sentarse con su jefe y tratar de explicar racionalmente por qué un forciclo tiene un propósito. Hay momentos en que un forbloque de iteración describe más claramente un algoritmo que una foreachiteración. Cuando esto es cierto, es apropiado usarlos.

También le diría a su jefe: el rendimiento no es, y no debería ser un problema de ninguna manera práctica, es más una cuestión de expresión del algoritmo de una manera sucinta, significativa y sostenible. Las micro optimizaciones como esta pierden por completo el punto de la optimización del rendimiento, ya que cualquier beneficio real del rendimiento vendrá del rediseño algorítmico y la refactorización, no de la reestructuración en bucle.

Si, después de una discusión racional, todavía existe este punto de vista autoritario, depende de usted cómo proceder. Personalmente, no sería feliz trabajando en un entorno donde se desalienta el pensamiento racional, y consideraría mudarme a otro puesto bajo un empleador diferente. Sin embargo, recomiendo encarecidamente la discusión antes de enfadarse; puede que haya un simple malentendido.

Es lo que haces dentro del bucle lo que afecta el rendimiento, no la construcción de bucle real (suponiendo que tu caso no sea trivial).

Si fores más rápido de lo que foreachrealmente es, además del punto. Dudo seriamente que elegir uno sobre el otro tenga un impacto significativo en su rendimiento.

La mejor manera de optimizar su aplicación es mediante la creación de perfiles del código real. Eso determinará los métodos que representan la mayor parte del trabajo / tiempo. Optimizar esos primero. Si el rendimiento aún no es aceptable, repita el procedimiento.

Como regla general, recomendaría mantenerse alejado de las micro optimizaciones, ya que rara vez producirán ganancias significativas. La única excepción es cuando se optimizan las rutas activas identificadas (es decir, si su perfil identifica algunos métodos muy utilizados, puede tener sentido optimizarlos ampliamente).

Los dos correrán casi exactamente de la misma manera. Escriba un código para usar ambos, luego muéstrele el IL. Debe mostrar cálculos comparables, lo que significa que no hay diferencia en el rendimiento.

tiene una lógica más simple de implementar, por lo que es más rápido que foreach.

A menos que esté en un proceso de optimización de velocidad específico, diría que use el método que produzca el código más fácil de leer y mantener.

Si un iterador ya está configurado, como con una de las clases de colección, entonces el foreach es una buena opción fácil. Y si está iterando un rango entero, entonces probablemente sea más limpio.

Jeffrey Richter habló sobre la diferencia de rendimiento entre for y foreach en un podcast reciente: http://pixel8.infragistics.com/shows/everything.aspx#Episode:9317

En la mayoría de los casos, realmente no hay diferencia.

Por lo general, siempre tiene que usar foreach cuando no tiene un índice numérico explícito, y siempre tiene que usar para cuando realmente no tiene una colección iterable (por ejemplo, iterar sobre una cuadrícula de matriz bidimensional en un triángulo superior) . Hay algunos casos en los que tiene una opción.

Se podría argumentar que los bucles for pueden ser un poco más difíciles de mantener si los números mágicos comienzan a aparecer en el código. Debería tener razón al estar molesto por no poder usar un bucle for y tener que construir una colección o usar una lambda para construir una subcolección solo porque los bucles for han sido prohibidos.

Parece un poco extraño prohibir totalmente el uso de algo así como un bucle for.

Hay un artículo interesante aquí. que cubre una gran cantidad de las diferencias de rendimiento entre los dos bucles.

Personalmente, creo que foreach es un poco más legible para los bucles, pero debe usar lo mejor para el trabajo en cuestión y no tener que escribir un código extralargo para incluir un bucle foreach si un bucle for es más apropiado.

Encontré el foreachciclo que itera a través de un List más rápido . Vea los resultados de mi prueba a continuación. En el código de abajo I iterar una arrayde tamaño 100, 10000 y 100000 por separado utilizando fory foreachbucle para medir el tiempo.

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);
    }

ACTUALIZADO

Después de la sugerencia de @jgauffin, utilicé el código de @johnskeet y descubrí que el forbucle con arrayes más rápido que el siguiente,

• Bucle Foreach con matriz.
• Para bucle con lista.
• Foreach loop con lista.

Vea los resultados de mi prueba y el código a continuación,

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);
    }

Realmente puedes atornillar su cabeza e ir por un cierre IQueryable .foreach en su lugar:

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

No esperaría que nadie encontrara una "enorme" diferencia de rendimiento entre los dos.

Supongo que la respuesta depende de si la colección a la que está intentando acceder tiene una implementación de acceso de indexador más rápida o una implementación de acceso de IEnumerator más rápida. Como IEnumerator a menudo usa el indexador y solo contiene una copia de la posición actual del índice, esperaría que el acceso al enumerador sea al menos tan lento o más lento que el acceso directo al índice, pero no mucho.

Por supuesto, esta respuesta no tiene en cuenta las optimizaciones que el compilador puede implementar.

Tenga en cuenta que el bucle for y el bucle foreach no siempre son equivalentes. Los enumeradores de listas arrojarán una excepción si la lista cambia, pero no siempre obtendrá esa advertencia con un ciclo for normal. Incluso puede obtener una excepción diferente si la lista cambia en el momento equivocado.