Em C # / VB.NET / .NET, qual loop é executado mais rapidamente forou foreach?

Desde que li que um forloop funciona mais rápido do que um foreachloop há muito tempo, presumi que fosse verdade para todas as coleções, coleções genéricas, todas as matrizes etc.

Vasculhei o Google e encontrei alguns artigos, mas a maioria deles é inconclusiva (leia os comentários nos artigos) e é aberta.

O ideal seria ter cada cenário listado e a melhor solução para o mesmo.

Por exemplo (apenas um exemplo de como deve ser):

1. para iterar uma matriz de mais de 1000 strings - foré melhor queforeach
2. para iterar sobre IListcadeias (não genéricas) - foreaché melhor quefor

Algumas referências encontradas na web para o mesmo:

1. Artigo grandioso original de Emmanuel Schanzer
2. CodeProject FOREACH vs. PARA
3. Blog - Para foreachou não foreach, eis a questão
4. Fórum ASP.NET - NET 1.1 C # forvsforeach

[Editar]

Além do aspecto de legibilidade, estou realmente interessado em fatos e números. Existem aplicativos em que a última milha de otimização de desempenho compactada é importante.

Patrick Smacchia escreveu um blog sobre este mês passado, com as seguintes conclusões:

• para loops na lista são um pouco mais de duas vezes mais baratos que os loops foreach na lista.
• Fazer um loop na matriz é cerca de duas vezes mais barato do que fazer um loop na lista.
• Como conseqüência, o loop no array usando for é 5 vezes mais barato do que o loop no List usando foreach (que eu acredito que é o que todos nós fazemos).

Primeiro, uma reconvenção à resposta de Dmitry (agora excluída) . Para matrizes, o compilador C # emite praticamente o mesmo código foreachque seria para um forloop equivalente . Isso explica por que, para esse benchmark, os resultados são basicamente os mesmos:

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

Em seguida, confirme se o argumento de Greg sobre o tipo de coleção é importante - altere a matriz para a List<double>no exemplo acima e você obtém resultados radicalmente diferentes. Não é apenas significativamente mais lento em geral, mas o foreach se torna significativamente mais lento do que o acesso por índice. Dito isto, eu quase sempre preferiria foreach a um loop for, onde ele torna o código mais simples - porque a legibilidade é quase sempre importante, enquanto a micro-otimização raramente é.

foreachloops demonstram intenção mais específica do que forloops .

O uso de um foreachloop demonstra para qualquer pessoa que use seu código que você está planejando fazer algo para cada membro de uma coleção, independentemente do seu lugar na coleção. Também mostra que você não está modificando a coleção original (e lança uma exceção, se tentar).

A outra vantagem foreachdisso é que ele funciona em qualquer um IEnumerable, onde forapenas faz sentido IList, onde cada elemento realmente possui um índice.

No entanto, se você precisar usar o índice de um elemento, é claro que poderá usar um forloop. Mas se você não precisar usar um índice, ter um está apenas sobrecarregando seu código.

Não há implicações significativas de desempenho, até onde eu saiba. Em algum momento no futuro, pode ser mais fácil adaptar o código foreachpara rodar em vários núcleos, mas isso não é algo para se preocupar no momento.

Sempre que houver argumentos sobre desempenho, basta escrever um pequeno teste para poder usar resultados quantitativos para apoiar seu caso.

Use a classe StopWatch e repita algo alguns milhões de vezes, para maior precisão. (Isso pode ser difícil sem um loop 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

Os dedos cruzaram os resultados disso e mostram que a diferença é insignificante, e você também pode fazer o que resultar no código mais sustentável

Sempre estará perto. Para uma matriz, às vezes for é um pouco mais rápido, mas foreaché mais expressivo, oferece LINQ etc. etc. Em geral, atenha-se a foreach.

Além disso, foreachpode ser otimizado em alguns cenários. Por exemplo, uma lista vinculada pode ser terrível pelo indexador, mas pode ser rápida foreach. Na verdade, o padrão LinkedList<T>nem sequer oferece um indexador por esse motivo.

Meu palpite é que provavelmente não será significativo em 99% dos casos, então por que você escolheria o mais rápido em vez do mais apropriado (como é o mais fácil de entender / manter)?

É improvável que haja uma enorme diferença de desempenho entre os dois. Como sempre, quando confrontado com um "que é mais rápido?" pergunta, você deve sempre pensar "eu posso medir isso".

Escreva dois loops que fazem a mesma coisa no corpo do loop, execute e cronometre os dois e veja qual é a diferença de velocidade. Faça isso com um corpo quase vazio e um corpo em loop semelhante ao que você realmente estará fazendo. Tente também com o tipo de coleção que você está usando, porque diferentes tipos de coleções podem ter características de desempenho diferentes.

Existem boas razões para preferir foreach loops a forloops. Se você pode usar um foreachloop, seu chefe está certo que deveria.

No entanto, nem toda iteração está simplesmente passando por uma lista em ordem uma por uma. Se ele está proibindo , sim, isso está errado.

Se eu fosse você, o que faria seria transformar todos os seus loops naturais em recursão . Isso o ensinaria, e também é um bom exercício mental para você.

Jeffrey Richter no TechEd 2005:

"Aprendi ao longo dos anos que o compilador C # é basicamente um mentiroso para mim." .. "Encontra-se sobre muitas coisas." .. "Como quando você faz um loop foreach ..." .. "... essa é uma pequena linha de código que você escreve, mas o que o compilador C # divulga para fazer isso é fenomenal. tente / finalmente bloqueie lá dentro, dentro do bloco finalmente, lança sua variável para uma interface IDisposable e, se o elenco for bem-sucedido, chama o método Dispose, dentro do loop chama a propriedade Current e o método MoveNext repetidamente dentro do loop, objetos estão sendo criados por baixo das capas. Muitas pessoas usam o foreach porque é muito fácil de codificar, muito fácil de fazer .. ".." foreach não é muito bom em termos de desempenho,

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

Isto é ridículo. Não há motivo convincente para proibir o loop for, em termos de desempenho ou outro.

Consulte o blog de Jon Skeet para obter uma referência de desempenho e outros argumentos.

Nos casos em que você trabalha com uma coleção de objetos, foreaché melhor, mas se você incrementar um número, umfor loop é melhor.

Observe que, no último caso, você pode fazer algo como:

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

Mas certamente não tem um desempenho melhor, na verdade, tem desempenho pior comparado a um for.

Isso deve te salvar:

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

Usar:

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

Para uma vitória maior, você pode levar três delegados como parâmetros.

você pode ler sobre isso no Deep .NET - parte 1 Iteração

abrange os resultados (sem a primeira inicialização) do código-fonte .NET até a desmontagem.

por exemplo - Iteração de matriz com um loop foreach:

e - liste a iteração com o loop foreach:

e os resultados finais:

As diferenças de velocidade em um loop for- e um foreachloop são pequenas quando você percorre estruturas comuns como matrizes, listas, etc.LINQ consulta sobre a coleção é quase sempre um pouco mais lento, embora seja mais agradável para escrever! Como os outros pôsteres disseram, busque expressividade em vez de um milissegundo de desempenho extra.

O que não foi dito até agora é que, quando um foreachloop é compilado, ele é otimizado pelo compilador com base na coleção em que ele está interagindo. Isso significa que, quando você não tiver certeza de qual loop usar, deverá usar oforeach -lo - ele gerará o melhor loop para você quando for compilado. É mais legível também.

Outra vantagem importante do foreachloop é que, se a implementação da sua coleção mudar (de um int arraypara um List<int>por exemplo), seu foreachloop não exigirá nenhuma alteração no código:

foreach (int i in myCollection)

O acima é o mesmo, independentemente do tipo de sua coleção, enquanto no seu forloop, o seguinte não será gerado se você alterar myCollectionde um arraypara um List:

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

"Existe algum argumento que eu possa usar para me ajudar a convencê-lo de que o loop for é aceitável?"

Não, se o seu chefe está gerenciando ao nível de lhe dizer qual linguagem de programação constrói para usar, não há realmente nada que você possa dizer. Desculpa.

Provavelmente depende do tipo de coleção que você está enumerando e da implementação de seu indexador. Em geral, porém, o uso foreachprovavelmente será uma abordagem melhor.

Além disso, funcionará com qualquer um IEnumerable- e não apenas com indexadores.

Isso tem as mesmas duas respostas que a maioria das perguntas "o que é mais rápido":

1) Se você não mede, você não sabe.

2) (Porque ...) Depende.

Depende de quanto o método "MoveNext ()" é caro, em relação à forma como o método "this [int index]" é caro, para o tipo (ou tipos) de IEnumerable que você estará repetindo.

A palavra-chave "foreach" é uma abreviação de uma série de operações - chama GetEnumerator () uma vez no IEnumerable, chama MoveNext () uma vez por iteração, faz alguma verificação de tipo e assim por diante. A coisa com maior probabilidade de afetar as medições de desempenho é o custo de MoveNext (), uma vez que isso é invocado O (N) vezes. Talvez seja barato, mas talvez não seja.

A palavra-chave "for" parece mais previsível, mas na maioria dos loops "for" você encontrará algo como "coleção [índice]". Parece uma operação simples de indexação de matriz, mas na verdade é uma chamada de método, cujo custo depende inteiramente da natureza da coleção que você está repetindo. Provavelmente é barato, mas talvez não seja.

Se a estrutura subjacente da coleção for essencialmente uma lista vinculada, o MoveNext é muito barato, mas o indexador pode ter um custo O (N), criando o custo real de um loop O (N * N) "for".

Cada construção de idioma tem um horário e local apropriados para uso. Há uma razão pela qual a linguagem C # possui quatro instruções de iteração separadas - cada uma existe para uma finalidade específica e tem um uso apropriado.

Eu recomendo sentar com seu chefe e tentar explicar racionalmente por que um forloop tem um propósito. Há momentos em que um forbloco de iteração descreve mais claramente um algoritmo do que uma foreachiteração. Quando isso é verdade, é apropriado usá-los.

Eu também apontaria para o seu chefe - o desempenho não é e não deve ser um problema de maneira prática - é mais uma questão de expressar o algoritmo de maneira sucinta, significativa e sustentável. Micro-otimizações como essa perdem completamente o ponto de otimização de desempenho, pois qualquer benefício real de desempenho virá do redesenho e refatoração algorítmica, e não da reestruturação em loop.

Se, após uma discussão racional, ainda houver essa visão autoritária, cabe a você decidir como proceder. Pessoalmente, eu não ficaria feliz em trabalhar em um ambiente em que o pensamento racional é desencorajado e consideraria mudar para outra posição sob outro empregador. No entanto, eu recomendo fortemente a discussão antes de ficar chateado - pode haver apenas um simples mal-entendido.

É o que você faz dentro do loop que afeta o desempenho, não a construção real do loop (supondo que seu caso não seja trivial).

Se foré mais rápido do que foreachrealmente está além do ponto. Eu duvido seriamente que escolher um sobre o outro tenha um impacto significativo no seu desempenho.

A melhor maneira de otimizar seu aplicativo é através da criação de perfil do código real. Isso identificará os métodos que representam mais trabalho / tempo. Otimize aqueles primeiro. Se o desempenho ainda não for aceitável, repita o procedimento.

Como regra geral, eu recomendaria ficar longe das micro otimizações, pois elas raramente geram ganhos significativos. A única exceção é ao otimizar os caminhos ativos identificados (ou seja, se sua criação de perfil identificar alguns métodos altamente usados, pode fazer sentido otimizá-los extensivamente).

Os dois serão executados quase exatamente da mesma maneira. Escreva algum código para usar os dois e mostre a ele a IL. Ele deve mostrar cálculos comparáveis, o que significa que não há diferença no desempenho.

O for tem uma lógica mais simples de implementar, por isso é mais rápido que o foreach.

A menos que você esteja em um processo específico de otimização de velocidade, eu diria que use qualquer método que produza o código mais fácil de ler e manter.

Se um iterador já estiver configurado, como em uma das classes de coleção, o foreach é uma boa opção fácil. E se você estiver repetindo um intervalo inteiro, provavelmente será mais limpo.

Jeffrey Richter falou sobre a diferença de desempenho entre for e foreach em um podcast recente: http://pixel8.infragistics.com/shows/everything.aspx#Episode:9317

Na maioria dos casos, não há realmente nenhuma diferença.

Normalmente, você sempre precisa usar foreach quando não possui um índice numérico explícito e sempre precisa usar quando não possui uma coleção iterável (por exemplo, iterando sobre uma grade de matriz bidimensional em um triângulo superior) . Existem alguns casos em que você tem uma escolha.

Alguém poderia argumentar que para loops pode ser um pouco mais difícil de manter se números mágicos começarem a aparecer no código. Você deve estar aborrecido por não poder usar um loop for e ter que criar uma coleção ou usar um lambda para criar uma subcoleção, apenas porque os loops foram banidos.

Parece um pouco estranho proibir totalmente o uso de algo como um loop for.

Há um artigo interessante aqui que aborda muitas diferenças de desempenho entre os dois loops.

Eu diria que pessoalmente acho o foreach um pouco mais legível para loops, mas você deve usar o melhor para o trabalho em questão e não precisa escrever um código extra longo para incluir um loop foreach se um loop for for mais apropriado.

Eu encontrei o foreachloop que iterava através de um List mais rápido . Veja meus resultados de teste abaixo. No código abaixo eu iterar um arrayde tamanho 100, 10000 e 100000 usando separadamente fore foreachcircuito para medir o tempo.

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

ATUALIZADA

Após a sugestão @jgauffin, usei o código @johnskeet e descobri que o forloop com arrayé mais rápido que o seguinte,

• Foreach loop com matriz.
• For loop com lista.
• Foreach loop com lista.

Veja meus resultados e código de teste abaixo,

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

Você pode realmente estragar a cabeça dele e optar por um fechamento .foreach IQueryable:

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

Eu não esperaria que alguém encontrasse uma "enorme" diferença de desempenho entre os dois.

Eu acho que a resposta depende se a coleção que você está tentando acessar possui uma implementação mais rápida de acesso ao indexador ou uma implementação mais rápida de acesso ao IEnumerator. Como o IEnumerator geralmente usa o indexador e apenas mantém uma cópia da posição atual do índice, eu esperaria que o acesso ao enumerador fosse pelo menos tão lento ou mais lento que o acesso direto ao índice, mas não muito.

Obviamente, essa resposta não leva em conta nenhuma otimização que o compilador possa implementar.

Lembre-se de que o loop for e foreach nem sempre são equivalentes. Os enumeradores de lista lançarão uma exceção se a lista for alterada, mas você nem sempre receberá esse aviso com um loop for normal. Você pode até receber uma exceção diferente se a lista mudar no momento errado.