¿Qué es más rápido en un bucle: llamar una propiedad dos veces o almacenar la propiedad una vez?

Question

Esto es más una pregunta académica sobre el rendimiento que un "qué debería usar" realista, pero tengo curiosidad ya que no hago mucho en IL para ver qué está construido y no tengo un gran conjunto de datos en mano al perfil contra.

Así que es más rápido:

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

o:

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

tener en cuenta que en realidad no quiero saber el impacto en el rendimiento de la string.Add (s) (como cualquier operación que necesite hacerse realmente no se puede cambiar), solo la diferencia de rendimiento entre la configuración s cada iteración (digamos que s puede ser cualquier tipo primitivo o cadena) versos que llaman al getter sobre el objeto en cada iteración.

Answer 1

Su primera opción es notablemente más rápida en mis pruebas. ¡Soy como flip flopper!En serio, algunos comentarios se hicieron sobre el código en mi prueba original. Aquí está el código actualizado que muestra que la opción 2 es más rápida.

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

La mayoría de las veces, su segundo fragmento de código debe ser al menos tan rápido como el primer fragmento.

Estos dos fragmentos de código no son funcionalmente equivalentes. No se garantiza que las propiedades devuelvan el mismo resultado en los accesos individuales. Como consecuencia, el optimizador JIT no puede almacenar en caché el resultado (excepto en casos triviales) y será más rápido si guarda en caché el resultado de una propiedad de larga ejecución. Mira este ejemplo: why foreach is faster than for loop while reading richtextbox lines.

Sin embargo, para algunos casos específicos como:

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

donde myArray es un objeto de matriz, el compilador es capaz de detectar el patrón y optimizar el código y omitir los controles consolidados. Podría ser más lento si guardar en caché el resultado de Length propiedad como:

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

Answer 3

Almacenar el valor en un campo es la opción más rápida.

Aunque una llamada a método no impone una gran sobrecarga, supera con creces el almacenamiento del valor una vez a una variable local en la pila y luego recuperarlo.

Por mi parte, lo hago constantemente.

Answer 4

Generalmente, el segundo es más rápido, ya que el primero recalcula la propiedad en cada iteración. Aquí es un ejemplo de algo que podría tener cantidad significativa de tiempo:

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

Answer 5

Realmente depende de la implementación. En la mayoría de los casos, se asume (como una práctica común/cortesía) que una propiedad no es costosa. Sin embargo, podría ocurrir que cada "get" realice una búsqueda no almacenada en caché sobre algún recurso remoto. Para propiedades simples y estándar, nunca notará una diferencia real entre los dos. En el peor de los casos, buscar una vez, almacenar y reutilizar será mucho más rápido.

Estaría tentado de usar get dos veces hasta que sepa que hay un problema ... "optimización prematura", etc ... Pero; si lo estuviera usando en un ciclo cerrado, , entonces Podría almacenarlo en una variable. Excepto por Length en una matriz, que tiene tratamiento JIT especial ;-p