¿Por qué declarar variables cerca de donde se usan?

He escuchado a personas decir que las variables deben declararse lo más cerca posible de su uso. No entiendo esto

Por ejemplo, esta política sugeriría que debería hacer esto:

foreach (var item in veryLongList) {
  int whereShouldIBeDeclared = item.Id;
  //...
}

Pero seguramente esto significa que los gastos generales de la creación de una nueva intse incurre en cada iteración. ¿No sería mejor usar:

int whereShouldIBeDeclared;
foreach (var item in veryLongList) {
  whereShouldIBeDeclared = item.Id;
  //...
}

Por favor alguien podría explicar?

Esta es una regla de estilo entre muchas, y no es necesariamente la regla más importante de todas las reglas posibles que podrías considerar. Su ejemplo, dado que incluye un int, no es súper convincente, pero ciertamente podría tener un objeto costoso de construir dentro de ese ciclo, y quizás un buen argumento para construir el objeto fuera del ciclo. Sin embargo, eso no lo convierte en un buen argumento en contra de esta regla, ya que primero, hay toneladas de otros lugares que podría aplicar que no implican la construcción de objetos caros en un bucle, y segundo, un buen optimizador (y ha etiquetado C #, para que tenga un buen optimizador) puede izar la inicialización fuera del ciclo.

La verdadera razón de esta regla también es la razón por la que no ves por qué es una regla. La gente solía escribir funciones que tenían cientos, incluso miles de líneas de largo y solía escribirlas en editores de texto sin formato (piense en el Bloc de notas) sin el tipo de soporte que proporciona Visual Studio. En ese entorno, declarar una variable a cientos de líneas de donde se usaba significaba que la persona que leía

if (flag) limit += factor;

no tenía muchas pistas sobre qué bandera, límite y factor eran. Se adoptaron convenciones de nomenclatura como la notación húngara para ayudar con esto, y también reglas como declarar cosas cercanas a donde se usan. Por supuesto, en estos días, todo se trata de refactorizar, y las funciones generalmente duran menos de una página, lo que dificulta la distancia entre el lugar donde se declaran las cosas y donde se usan. Estás operando en un rango de 0-20 y estás discutiendo que tal vez 7 está bien en este caso en particular, mientras que el tipo que hizo la regla habría AMADO tener 7 líneas de distancia y estaba tratando de convencer a alguien de 700. Y en Además de eso, en Visual Studio, puede pasar el mouse sobre cualquier cosa y ver su tipo, si es una variable miembro, etc. Eso significa que la necesidad de ver la línea que lo declara disminuye.

Sigue siendo una regla razonablemente buena, una que en realidad es bastante difícil de romper en estos días, y una que nadie abogó como razón para escribir código lento. Sé sensible, sobre todo.

La definición de la variable dentro del bucle hace que la visibilidad sea local solo para ese bucle. Esto tiene al menos 3 ventajas para el lector:

1. La definición variable y cualquier comentario relacionado son fáciles de encontrar
2. El lector sabe que esta variable nunca se usa en otro lugar donde (no hay dependencia que esperar)
3. Cuando el código se escribe o edita, no hay posibilidad de que pueda usar el mismo nombre de variable fuera del bucle para referirse a esa variable, de lo contrario, podría obtener un error.

En cuanto al bit de eficiencia, el compilador es inteligente para generar la definición fuera del bucle en el código optimizado generado. La variable no se creará en cada iteración del bucle.

Las personas dicen que lo más cerca posible de su uso , no dicen que debas hacer eso todo el tiempo, porque en algunos casos, declarar que las variables en el menor alcance causarán cierta sobrecarga. Las principales razones de esa declaración son la legibilidad y las variables El alcance más pequeño que puedas.

Aunque ayuda con la legibilidad, la legibilidad no es la consideración principal en este caso, y los IDE modernos no obvian la necesidad de esta regla.

La principal preocupación son las variables no inicializadas. Si declaras una variable demasiado lejos de su inicialización, te abre a todo tipo de problemas potenciales. Es posible que te encuentres trabajando accidentalmente con lo que sea que haya estado allí antes en la RAM, o el resultado de un cálculo más alto en la función, o una inicialización ficticia (como 0) que alguien puso solo para evitar que el compilador se queje. Las personas insertarán código entre su declaración y uso sin ser conscientes de sus condiciones previas implícitas para esa variable. En el peor de los casos, ese uso funcionará en tus pruebas pero fallará en el campo.

Declarar sus variables en el menor alcance posible e inicializarlas en un valor adecuado justo en el punto de declaración evitará muchos dolores de cabeza de mantenimiento. El hecho de que obliga a mejorar la legibilidad es solo un buen efecto secundario.

No es un "must". Es solo una opinión, es una manera de hacer algo. Por ejemplo, me gusta declarar todos los vars en las primeras líneas del método para poder comentar qué haré con esos vars (por supuesto, a menos que sean contadores). A otras personas, como escucharon, les gusta colocarlas lo más cerca posible de su uso (como en el segundo ejemplo que escribió). De todos modos, el primer ejemplo que proporcione es seguramente un "error" (en el sentido de que causará una sobrecarga como usted lo entiende).

Simplemente tiene que elegir su camino y seguirlo.

Sus dos ejemplos son códigos funcionalmente diferentes, no son intercambiables. (Sus ejemplos simplificados le dejan una distinción sin diferencia, pero en un código no trivial hace la diferencia). La regla de su sitio siempre está subordinada a consideraciones de alcance, como se indica con "... como sea posible".