Was ist schneller in einer Schleife: eine Eigenschaft zweimal aufrufen oder die Eigenschaft einmal speichern?

Question

Dies ist eher eine akademische Frage zur Leistung als ein realistisches "Was soll ich verwenden?", Aber ich bin neugierig, da ich mich nicht viel mit ILs beschäftige, um zu sehen, was konstruiert ist und auf dem ich keinen großen Datensatz habe Hand zum Profil gegen.

So, das ist schneller:

List<myObject> objs = SomeHowGetList(); 
List<string> strings = new List<string>(); 
foreach (MyObject o in objs) 
{ 
    if (o.Field == "something") 
     strings.Add(o.Field); 
} 

oder:

List<myObject> objs = SomeHowGetList(); 
List<string> strings = new List<string>(); 
string s; 
foreach (MyObject o in objs) 
{ 
    s = o.Field; 
    if (s == "something") 
     strings.Add(s); 
} 

Beachten Sie, dass ich will nicht wirklich die Auswirkungen auf die Leistung der string.Add (n) wissen (wie was auch immer ausgeführt werden muss, kann nicht wirklich geändert werden), nur der Leistungsunterschied zwischen der Einstellung jeder Iteration (sagen wir mal, dass s irgendein primitiver Typ oder String sein kann) und dem Aufruf des Getter auf dem Objekt bei jeder Iteration.

Answer 1

Ihre erste Option ist spürbar schneller in meinen Tests. Ich bin so ein Flip Flopper!Im Ernst, einige Kommentare wurden über den Code in meinem ursprünglichen Test gemacht. Hier ist der aktualisierte Code, der zeigt, dass Option 2 schneller ist.

class Foo 
    { 
     public string Bar { get; set; } 

     public static List<Foo> FooMeUp() 
     { 
      var foos = new List<Foo>(); 

      for (int i = 0; i < 10000000; i++) 
      { 
       foos.Add(new Foo() { Bar = (i % 2 == 0) ? "something" : i.ToString() }); 
      } 

      return foos; 
     } 
    } 

    static void Main(string[] args) 
    { 

     var foos = Foo.FooMeUp(); 
     var strings = new List<string>(); 

     Stopwatch sw = Stopwatch.StartNew(); 

     foreach (Foo o in foos) 
     { 
      if (o.Bar == "something") 
      { 
       strings.Add(o.Bar); 
      } 
     } 

     sw.Stop(); 
     Console.WriteLine("It took {0}", sw.ElapsedMilliseconds); 

     strings.Clear(); 
     sw = Stopwatch.StartNew(); 

     foreach (Foo o in foos) 
     { 
      var s = o.Bar; 
      if (s == "something") 
      { 
       strings.Add(s); 
      } 
     } 

     sw.Stop(); 
     Console.WriteLine("It took {0}", sw.ElapsedMilliseconds); 
     Console.ReadLine(); 
    } 

Answer 2

Die meiste Zeit sollte Ihr zweites Code-Snippet mindestens so schnell wie das erste Snippet sein.

Diese beiden Codefragmente sind nicht funktional gleichwertig. Es wird nicht garantiert, dass Eigenschaften das gleiche Ergebnis über einzelne Zugriffe zurückgeben. Daher kann der JIT-Optimierer das Ergebnis nicht zwischenspeichern (mit Ausnahme von trivialen Fällen), und er wird schneller, wenn Sie das Ergebnis einer Eigenschaft mit langer Laufzeit zwischenspeichern. Schauen Sie sich dieses Beispiel an: why foreach is faster than for loop while reading richtextbox lines.

jedoch für einige spezielle Fälle wie:

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

wo myArray ein Array-Objekt ist, ist der Compiler in der Lage, das Muster zu erkennen und den Code und lassen Sie die gebundenen Kontrollen zu optimieren. Es könnte langsamer sein, wenn Sie das Ergebnis der Length Eigenschaft wie Cache:

int len = myArray.Length; 
for (int i = 0; i < myArray.Length; ++i) 

Answer 3

den Wert in einem Feld Speichern ist die schnellere Option.

Obwohl ein Methodenaufruf keinen großen Aufwand verursacht, ist es bei weitem wichtiger, den Wert einmal auf einer lokalen Variablen im Stapel zu speichern und dann abzurufen.

Ich für einen mache es konsequent.

Answer 4

Im Allgemeinen ist die zweite schneller, da die erste die Eigenschaft bei jeder Iteration neu berechnet. Hier ist ein Beispiel für etwas, die erhebliche Menge an Zeit in Anspruch nehmen könnte: Es hängt wirklich von der Umsetzung

var d = new DriveInfo("C:"); 
d.VolumeLabel; // will fetch drive label on each call 

Answer 5

. In den meisten Fällen wird (in der üblichen Praxis/Höflichkeit) davon ausgegangen, dass eine Immobilie billig ist. Es könnte jedoch sein, dass jede "get" eine nicht zwischengespeicherte Suche über eine entfernte Ressource ausführt. Für standardmäßige, einfache Eigenschaften werden Sie nie einen wirklichen Unterschied zwischen den beiden bemerken. Im schlimmsten Fall wird das Holen, Speichern und Wiederverwenden viel schneller sein.

Ich wäre versucht, get zweimal zu verwenden, bis ich weiß, dass es ein Problem gibt ... "vorzeitige Optimierung", etc ... Aber; wenn ich es in einer engen Schleife verwendete, dann Ich könnte es in einer Variablen speichern. Außer Length auf einem Array, das spezielle JIT-Behandlung hat; -p