Declarar una variable dentro o fuera de un bucle foreach: ¿cuál es más rápido / mejor?

¿Cuál de estos es el más rápido / mejor?

Éste:

List<User> list = new List<User>();
User u;

foreach (string s in l)
{
    u = new User();
    u.Name = s;
    list.Add(u);
}

O este:

List<User> list = new List<User>();

foreach (string s in l)
{
    User u = new User();
    u.Name = s;
    list.Add(u);
}

Mis habilidades de desarrollo novato me dicen que la primera es mejor, pero un amigo me dice que estoy equivocado, pero que no puede darme una buena razón por la cual la segunda es mejor.

¿Existe alguna diferencia en el rendimiento?

En cuanto al rendimiento, ambos ejemplos se compilan en el mismo IL, por lo que no hay diferencia.

El segundo es mejor, porque expresa más claramente su intención si usolo se usa dentro del ciclo.

En cualquier caso, la mejor manera sería usar un constructor que tome un Nombre ... o, de lo contrario, explotar la notación de llaves:

foreach (string s in l)
{
    list.Add(new User(s));
}

o

foreach (string s in l)
{
    list.Add(new User() { Name = s });
}

o incluso mejor, LINQ:

var list = l.Select( s => new User { Name = s});

Ahora, mientras que su primer ejemplo podría, en algunos casos, ser imperceptiblemente más rápido, el segundo es mejor porque es más legible y el compilador puede descartar la variable (y omitirla por completo) ya que no se usa fuera del foreachalcance del '.

Una declaración no hace que se ejecute ningún código, por lo que no es un problema de rendimiento.

El segundo es lo que quieres decir, y es menos probable que cometas un error estúpido si lo haces de la segunda forma, así que úsala. Intente siempre declarar variables en el ámbito más pequeño necesario.

Y además, la mejor forma es usar Linq:

List<User> users = l.Select(name => new User{ Name = name }).ToList();

Siempre que tenga una pregunta sobre el rendimiento, lo único que debe hacer es medir: ejecutar un ciclo alrededor de su prueba y cronometrarla.

Para responder a su pregunta, sin medir :-) o sin mirar el ilasma generado, ninguna diferencia se notaría en un número significativo de iteraciones y la operación más costosa en su código es probable que sea la asignación de usuarios por algunos pedidos. de magnitud, así que concéntrese en la claridad del código (como debería en general) y vaya con 2.

Oh, es tarde y supongo que solo intento decirte que no te preocupes por este tipo de cosas o te quedes atrapado en detalles como este.

K

El segundo es mejor. Quiere tener un nuevo usuario en cada iteración.

Técnicamente, el primer ejemplo ahorrará algunos nanosegundos porque el marco de la pila no tendrá que moverse para asignar una nueva variable, pero esta es una cantidad tan pequeña de tiempo de CPU que no lo notará, eso es si el compilador no lo hace. optimizar cualquier diferencia de todos modos.

En este escenario, la segunda versión es mejor.

En general, si solo necesita acceder al valor dentro del cuerpo de la iteración, elija la segunda versión. Por otro lado, si hay algún estado final, la variable se mantendrá más allá del cuerpo del ciclo, luego declare y luego use la primera versión.

No debería haber una diferencia perceptible en el rendimiento.

Otra referencia que se parece a la de arriba:

http://social.msdn.microsoft.com/forums/en-US/csharplanguage/thread/d43aaba5-a58b-4610-bea4-5bc5d6741f98

Fui a verificar este problema. Sorprendentemente descubrí en mis pruebas sucias que la segunda opción es incluso un poco más rápida todo el tiempo.

namespace Test
{
  class Foreach
  {
    string[] names = new[] { "ABC", "MNL", "XYZ" };

    void Method1()
    {
      List<User> list = new List<User>();
      User u;

      foreach (string s in names)
      {
        u = new User();
        u.Name = s;
        list.Add(u);
      }
    }

    void Method2()
    {

      List<User> list = new List<User>();

      foreach (string s in names)
      {
        User u = new User();
        u.Name = s;
        list.Add(u);
      }
    }
  }

  public class User { public string Name; }
}

Verifiqué el CIL pero no es idéntico.

Así que preparé algo para lo que quería que fuera una prueba mucho mejor.

namespace Test
{
  class Loop
  { 

    public TimeSpan method1 = new TimeSpan();
    public TimeSpan method2 = new TimeSpan();

    Stopwatch sw = new Stopwatch();

    public void Method1()
    {
      sw.Restart();

      C c;
      C c1;
      C c2;
      C c3;
      C c4;

      int i = 1000;
      while (i-- > 0)
      {
        c = new C();
        c1 = new C();
        c2 = new C();
        c3 = new C();
        c4 = new C();        
      }

      sw.Stop();
      method1 = method1.Add(sw.Elapsed);
    }

    public void Method2()
    {
      sw.Restart();

      int i = 1000;
      while (i-- > 0)
      {
        var c = new C();
        var c1 = new C();
        var c2 = new C();
        var c3 = new C();
        var c4 = new C();
      }

      sw.Stop();
      method2 = method2.Add(sw.Elapsed);
    }
  }

  class C { }
}

También en este caso, el segundo método siempre ganaba, pero luego verifiqué que el CIL no encontró diferencias.

No soy un gurú de la lectura de CIL, pero no veo ningún problema de declinación. Como ya se señaló, la declaración no es asignación, por lo que no hay una penalización de rendimiento en ella.

Prueba

namespace Test
{
  class Foreach
  {
    string[] names = new[] { "ABC", "MNL", "XYZ" };

    public TimeSpan method1 = new TimeSpan();
    public TimeSpan method2 = new TimeSpan();

    Stopwatch sw = new Stopwatch();

    void Method1()
    {
      sw.Restart();

      List<User> list = new List<User>();
      User u;

      foreach (string s in names)
      {
        u = new User();
        u.Name = s;
        list.Add(u);
      }

      sw.Stop();
      method1 = method1.Add(sw.Elapsed);
    }

    void Method2()
    {
      sw.Restart();

      List<User> list = new List<User>();

      foreach (string s in names)
      {
        User u = new User();
        u.Name = s;
        list.Add(u);
      }

      sw.Stop();
      method2 = method2.Add(sw.Elapsed);
    }
  }

  public class User { public string Name; }