Ist eine dieser For-Schleifen schneller als die andere?

Question

for (var keyValue = 0; keyValue < dwhSessionDto.KeyValues.Count; keyValue++) 
{...} 


var count = dwhSessionDto.KeyValues.Count; 
for (var keyValue = 0; keyValue < count; keyValue++) 
{...} 

Ich weiß, es gibt einen Unterschied zwischen den beiden, aber ist einer von ihnen schneller als der andere? Ich denke, der zweite ist schneller.

Answer 1

Ja, die erste Version ist viel langsamer. Schließlich habe ich nehme an, Sie mit Typen wie dies zu tun hat:

public class SlowCountProvider 
{ 
    public int Count 
    { 
     get 
     { 
      Thread.Sleep(1000); 
      return 10; 
     } 
    } 
} 

public class KeyValuesWithSlowCountProvider 
{ 
    public SlowCountProvider KeyValues 
    { 
     get { return new SlowCountProvider(); } 
    } 
} 

hier Ihre erste Schleife ~ 10 Sekunden in Anspruch nehmen wird, während Ihre zweite Schleife ~ 1 Sekunde dauern.

Natürlich könnten Sie argumentieren, dass die Annahme, dass Sie diesen Code verwenden, ungerechtfertigt ist - aber mein Punkt ist, dass die richtige Antwort von den beteiligten Typen abhängt, und die Frage nicht angibt, was diese Typen sind.

Nun, wenn Sie tatsächlich mit einer Art zu tun, wo KeyValues und Count Zugriff ist billig (was sehr wahrscheinlich ist) Ich würde nicht erwarten, dass viel Unterschied.Wohlgemerkt, ich würde fast immer lieber foreach verwenden, wo möglich:

foreach (var pair in dwhSessionDto.KeyValues) 
{ 
    // Use pair here 
} 

diese Weise können Sie nie die Zählung benötigen. Aber dann hast du auch nicht gesagt, was du in der Schleife machen willst. (Tipp: Um mehr nützliche Antworten zu erhalten, provide more information.)

Answer 2

Nein. Es gibt keinen Leistungsunterschied zwischen diesen beiden Schleifen. Mit JIT und Code Optimization macht es keinen Unterschied.

Answer 3

Siehe Kommentare für Gründe, warum diese Antwort falsch ist.

Wenn es einen Unterschied gibt, ist es umgekehrt: In der Tat, die erste man könnte schneller sein. Das liegt daran, dass der Compiler erkennt, dass Sie von 0 bis zum Ende des Arrays iterieren, und er kann daher innerhalb der Schleife Begrenzungsüberprüfungen durchführen (d. H. Wenn Sie auf dwhSessionDTo.KeyValues[i] zugreifen).

Ich glaube jedoch, dass der Compiler diese Optimierung nur auf Arrays anwendet, also wird es hier wahrscheinlich keinen Unterschied geben.

Answer 4

es hängt davon ab, wie schwierig es ist, dwhSessionDto.KeyValues.Count zu berechnen, wenn es nur ein Zeiger auf eine int dann die Geschwindigkeit jeder Version wird gleich sein. Wenn jedoch der Count Wert Bedarf berechnet wird, dann wird es jedes Mal berechnet werden, und daher perfomance behindern.

EDIT - here einig Code zeigen, dass die Bedingung immer

public class Temp 
{ 
    public int Count { get; set; } 
} 

static void Main(string[] args) 
{ 
    var t = new Temp() {Count = 5}; 
    for (int i = 0; i < t.Count; i++) 
    { 
     Console.WriteLine(i); 
     t.Count--; 
    } 
    Console.ReadLine(); 
} 

-bewertet re

Der Ausgang 0, 1, 2 - nur!

Answer 5

Es gibt keinen Unterschied ist aber, warum dieser Unterschied thereis, können Sie bitte Ihre Ergebnisse veröffentlichen?

, wenn Sie sehen die Umsetzung von Einsatz Artikel in Dictionary Reflektor

private void Insert(TKey key, TValue value, bool add) 
{ 
int freeList; 
if (key == null) 
{ 
    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key); 
} 
if (this.buckets == null) 
{ 
    this.Initialize(0); 
} 
int num = this.comparer.GetHashCode(key) & 0x7fffffff; 
int index = num % this.buckets.Length; 
for (int i = this.buckets[index]; i >= 0; i = this.entries[i].next) 
{ 
    if ((this.entries[i].hashCode == num) && this.comparer.Equals(this.entries[i].key, key)) 
    { 
     if (add) 
     { 
      ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate); 
     } 
     this.entries[i].value = value; 
     this.version++; 
     return; 
    } 
} 
if (this.freeCount > 0) 
{ 
    freeList = this.freeList; 
    this.freeList = this.entries[freeList].next; 
    this.freeCount--; 
} 
else 
{ 
    if (this.count == this.entries.Length) 
    { 
     this.Resize(); 
     index = num % this.buckets.Length; 
    } 
    freeList = this.count; 
    this.count++; 
} 
this.entries[freeList].hashCode = num; 
this.entries[freeList].next = this.buckets[index]; 
this.entries[freeList].key = key; 
this.entries[freeList].value = value; 
this.buckets[index] = freeList; 
this.version++; 

}

Count ist ein inneres Element dieser Klasse, die jedes Element erhöht wird Sie ein Element in Wörterbuch einfügen

also glaube ich, dass es überhaupt keinen Unterschied gibt.

Answer 6

Die zweite Version kann manchmal schneller sein. Der Punkt ist, dass die Bedingung nach jeder Iteration neu bewertet wird, wenn also z. der Getter von "Count" zählt tatsächlich die Elemente in einem IEnumerable oder interagiert eine Datenbank/etc, dies verlangsamt die Dinge.

Also würde ich sagen, dass, wenn Sie nicht den Wert von "Count" in der "für" beeinflussen, die zweite Version sicherer ist.

Answer 7

Es ist unmöglich zu sagen, ohne die Implementierung von dwhSessionDto.KeyValues.Count und den Schleifenkörper zu kennen.

Angenommen eine globale Variable bool foo = false; und dann folgende Implementierungen:

/* Loop body... */ 
{ 
    if(foo) Thread.Sleep(1000); 
} 

/* ... */ 
public int Count 
{ 
    get 
    { 
     foo = !foo;    
     return 10; 
    } 
} 
/* ... */ 

Nun wird die erste Schleife doppelt so schnell in etwa durchführt, wie die zweiten, D

jedoch unter der Annahme, nicht-moronic Implementierung des der zweite ist wahrscheinlicher schneller.