detener - foreach array c#
Declarar una variable dentro o fuera de un ciclo foreach: ¿cuál es más rápido/mejor? (9)
Cada vez que tenga una pregunta sobre el rendimiento, lo único que debe hacer es medir, ejecutar un ciclo alrededor de su prueba y medir el tiempo.
Para responder a su pregunta, sin medir :-) o mirando las ilasm generadas, cualquier diferencia no se notaría en un número significativo de iteraciones y la operación más costosa en su código probablemente sea la asignación del usuario por algunas órdenes. de magnitud, así que concéntrate en la claridad del código (como deberías en general) y ve con 2.
Oh, es tarde y creo que solo estoy tratando de decir que no te preocupes por este tipo de cosas o que te veas atrapado en detalles como este.
K
¿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 para el desarrollo de novatos me dicen que el primero es mejor, pero un amigo me dice que estoy equivocado, pero no podía darme una buena razón por la cual el segundo es mejor.
¿Hay alguna diferencia en el rendimiento en absoluto?
El segundo es mejor Quiere decir tener un nuevo usuario en cada iteración.
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, aunque su primer ejemplo podría, en algunos casos, ser increíblemente 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 alcance del alcance.
En este escenario, la segunda versión es mejor.
En general, si solo necesita acceder al valor dentro del cuerpo de la iteración, entonces 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, entonces declara y luego usa la primera versión.
En términos de rendimiento, ambos ejemplos se compilan en la misma IL, por lo que no hay diferencia.
El segundo es mejor, porque expresa más claramente tu intención si solo se usa dentro del ciclo.
No debería haber diferencias perceptibles en el rendimiento.
Otra referencia que se ve arriba:
Técnicamente, el primer ejemplo ahorrará unos nanosegundos porque no será necesario mover el marco de la pila para asignar una nueva variable, pero esta es una cantidad tan pequeña de tiempo de CPU que no lo notarás, es decir, si el compilador no lo hace optimizar cualquier diferencia de cualquier manera.
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 manera, así que úsalo. Intente siempre declarar las variables en el alcance más pequeño que sea necesario.
Y además, la mejor forma es usar Linq:
List<User> users = l.Select(name => new User{ Name = name }).ToList();