Perché il loop sull'oggetto array con `foreach` è più veloce di lambda` ForEach`?

Question

Io lavoro su un array e io devo ricollegarlo. In primo luogo, io uso lambda ForEach

Array 
.ForEach<int>(array, (int counter) => { 
    Console.WriteLine(counter); 
}); 

e poi io uso semplice foreach. Trovo che il semplice foreach sia così più veloce di lambda ForEach, ma quando lo provo con elenchi generici, ForEach è più veloce del semplice foreach.

perché il loop sull'oggetto array con foreach è più veloce di lambda ForEach? Aggiornamento: I test sulla serie

Answer 1

ho modificato il codice di Keith un po '- Sulla mia macchina foreach eseguita circa sei volte più veloce di Array.ForEach:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Benchmark(50); 
    } 

    private static void Benchmark(int iterations) 
    { 
     int[] list = Enumerable.Range(0, 100000000).ToArray(); 

     long sum = 0; 
     for (int i = 0; i < iterations; i++) 
     { 
      sum += ArrayForeach(list); 
     } 

     Console.WriteLine("ForEach " + sum/iterations); 

     sum = 0; 
     for (int i = 0; i < iterations; i++) 
     { 
      sum += Foreach(list); 
     } 

     Console.WriteLine("foreach " + sum/iterations); 
    } 

    private static long Foreach(int[] list) 
    { 
     long total = 0; 
     var stopWatch = Stopwatch.StartNew(); 
     foreach (var i in list) 
     { 
      total += i; 
     } 
     stopWatch.Stop(); 
     return stopWatch.ElapsedTicks; 
    } 

    private static long ArrayForeach(int[] list) 
    { 
     long total = 0; 
     var stopWatch = Stopwatch.StartNew(); 
     Array.ForEach(list, x => total += x); 
     stopWatch.Stop(); 
     return stopWatch.ElapsedTicks; 
    } 
} 

Sulla mia macchina (che potrebbe eseguire un CLR diverso rispetto ad altri) produce (in versione):

In Debug:

ForEach 941030 
foreach 845443 

• Esso dimostra che foreach gode di alcune ottimizzazioni del compilatore, credo principalmente ad accedere alla lista in memoria.
• In Debug, sembra l'overhead di eseguire il lambda e il superamento del numero (in base al valore) è responsabile della differenza.

suggerisco che qualcuno con più tempo a dare un'occhiata con riflettore ...

Answer 2

trovo la lambda più veloce nel mio test. Copia incollando il codice cronometro MSDNs e decorandolo con due versioni di iterazione di un elenco .... (Ho anche cambiato l'ordine del test che va per primo, e ottengo gli stessi tempi). L'iterazione basata su Linq con un lambda va più veloce.

Lambda 00:00:00.49 
foreach 00:00:00.58 

e il codice ..

var list = Enumerable.Range(0, 100000000).ToArray(); 
     var total = 0; 
     var stopWatch = new Stopwatch(); 
     stopWatch.Start(); 
     Array.ForEach(list, x => total += x); 

     stopWatch.Stop(); 
     TimeSpan ts = stopWatch.Elapsed; 
     string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
      ts.Hours, ts.Minutes, ts.Seconds, 
      ts.Milliseconds/10); 
     Console.WriteLine("RunTime " + elapsedTime); 


     stopWatch = new Stopwatch(); 
     stopWatch.Start(); 
     foreach (var i in list) 
     { 
      total += i; 
     }  
     stopWatch.Stop(); 
     // Get the elapsed time as a TimeSpan value. 
     ts = stopWatch.Elapsed; 

     // Format and display the TimeSpan value. 
     elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
      ts.Hours, ts.Minutes, ts.Seconds, 
      ts.Milliseconds/10); 
     Console.WriteLine("RunTime " + elapsedTime);