sintaxis - ¿Por qué un bucle for se comporta de manera diferente al migrar el código VB.NET a C#?

foreach c# explicacion

Question

Estoy en el proceso de migrar un proyecto de Visual Basic a C # y he tenido que cambiar cómo se declara el bucle for está utilizando.

En VB.NET el bucle for se declara a continuación:

Dim stringValue As String = "42"
For i As Integer = 1 To 10 - stringValue.Length
stringValue = stringValue & " " & CStr(i)
Console.WriteLine(stringValue)
Next

Qué salidas:

42 1
42 1 2
42 1 2 3
42 1 2 3 4
42 1 2 3 4 5
42 1 2 3 4 5 6
42 1 2 3 4 5 6 7
42 1 2 3 4 5 6 7 8

En C # el bucle for se declara a continuación:

string stringValue = "42";
for (int i = 1; i <= 10 - stringValue.Length; i ++)
{
stringValue = stringValue + " " + i.ToString();
Console.WriteLine(stringValue);
}

Y la salida:

42 1
42 1 2
42 1 2 3

Obviamente, esto no es correcto, así que tuve que cambiar el código ligeramente e incluí una variable entera que mantendría la longitud de la cadena.

Por favor, consulte el siguiente código:

string stringValue = "42";
int stringValueLength = stringValue.Length;
for (int i = 1; i <= 10 - stringValueLength; i ++)
{
stringValue = stringValue + " " + i.ToString();
Console.WriteLine(stringValue);
}

Y la salida:

42 1
42 1 2
42 1 2 3
42 1 2 3 4
42 1 2 3 4 5
42 1 2 3 4 5 6
42 1 2 3 4 5 6 7
42 1 2 3 4 5 6 7 8

Ahora mi pregunta se resuelve en torno a cómo Visual Basic se diferencia de C # en términos de Visual Basic usando la condición stringValue.Length en el bucle for , aunque cada vez que el bucle se produce, la longitud de la cadena cambia. Mientras que en C # si uso el stringValue.Length en la condición de bucle for , cambia el valor de la cadena inicial cada vez que se produce el bucle. ¿Por qué es esto?

Answer 1

Ahora mi pregunta se resuelve en torno a cómo VB se diferencia de C # en términos de VB usando la condición stringValue.Length en el bucle for, aunque cada vez que ocurre el bucle cambia la longitud de la cadena.

Según la documentación de VB.NET :

Si cambia el valor de counter mientras está dentro de un bucle, su código podría ser más difícil de leer y depurar. Cambiar el valor de start , end o step no afecta los valores de iteración que se determinaron cuando se ingresó por primera vez el ciclo.

Por lo tanto, el valor de To 10 - stringValue.Length se evalúa una vez y se reutiliza hasta que los bucles salen.

Sin embargo, mira c # ''s para la declaración

Si la for_condition no está presente o si la evaluación es true , el control se transfiere a la declaración incrustada. Cuando y si el control llega al punto final de la instrucción incrustada (posiblemente de la ejecución de una instrucción de continuación), las expresiones del for_iterator , si las hay, se evalúan en secuencia, y luego se realiza otra iteración, comenzando con la evaluación de la for_condition en. El paso anterior.

Lo que básicamente significa que la condición ; i <= 10 - stringValueLength; ; i <= 10 - stringValueLength; Se evalúa de nuevo cada vez.

Entonces, como vio, si desea replicar el código, debe declarar el contador final en c # antes de comenzar el ciclo.

Answer 2

Debido a que for en VB es una semántica diferente a la for in # C (o cualquier otro lenguaje similar a C)

En VB, la instrucción for está específicamente incrementando un contador de un valor a otro.

En C, C ++, C #, etc., la instrucción for simplemente evalúa tres expresiones:

• La primera expresión es habitualmente una inicialización.
• La segunda expresión se evalúa al comienzo de cada iteración para determinar si se ha cumplido la condición terminal
• La tercera expresión se evalúa al final de cada iteración, que suele ser un incrementador.

En VB, debe proporcionar una variable numérica que se pueda probar con un valor de terminal y se incremente en cada iteración

En C, C ++, C #, etc., las tres expresiones están mínimamente restringidas; la expresión condicional debe evaluarse como verdadera / falsa (o entero cero / no cero en C, C ++). No necesita realizar una inicialización, puede iterar cualquier tipo sobre cualquier rango de valores, iterar un puntero o referencia sobre una estructura compleja, o no iterar nada en absoluto.

Por lo tanto, en C #, etc., la expresión de condición debe evaluarse completamente en cada iteración, pero en VB, el valor terminal del iterador debe evaluarse al principio y no necesita ser evaluado nuevamente.

Answer 3

En C #, la condición de límite del bucle se evalúa en cada iteración. En VB.NET, solo se evalúa en la entrada al bucle.

Por lo tanto, en la versión de C # en la pregunta, debido a que la longitud de stringValue se está cambiando en el bucle, se cambiará el valor final de la variable del bucle.

En VB.NET, la condición final es inclusiva, por lo que usaría <= lugar de < en C #.

La evaluación de la condición final en C # tiene el corolario de que incluso si no varía pero es costoso de calcular, entonces se debe calcular solo una vez antes del bucle.

Answer 4

Para que el ejemplo sea más comprensible, convertiré ambos bucles en bucles C # while.

VB.NET

string stringValue = "42";
int min = 1;
int max = 10 - stringValue.Length;
int i = min;
while (i <= max)
{
stringValue = stringValue + " " + stringValue.Length.ToString();
Console.WriteLine(stringValue);
i++;
}

DO#

string stringValue = "42";
int i = 1;
while (i <= 10 - stringValue.Length)
{
stringValue = stringValue + " " + stringValue.Length.ToString();
Console.WriteLine(stringValue);
i++;
}

La diferencia es entonces:

VB.NET almacena en caché el valor máximo para i , pero C # lo vuelve a calcular cada vez.