Bucles while

int k = 1; guarda 1 antes de cualquier bucle. Luego while (k <= 3) sigue mientras esa prueba sea true. Dentro de las llaves, Console.WriteLine(k) escribe el número actual, y k = k + 1 guarda uno más bajo k. La pantalla muestra tres líneas: 1, luego 2, luego 3. Mantén el nombre de la clase pública Pine.

Inicio fuera, prueba en while, paso dentro

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier bucle for si esa línea sigue ahí, incluyendo for (int n = 1; n <= 3; n = n + 1) y cada inicio-prueba-paso empaquetado en un encabezado. Borra int choice si esa línea sigue. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura, no tiene un encabezado for con tres trabajos en paréntesis y no tiene switch. La pantalla solo la escribe la línea de escritura dentro de las llaves del while.

Dentro de Main, guarda primero el contador: int k = 1;. Esa línea no va dentro del while. Solo arranca k en 1. Luego el bucle:
while (k <= 3) {
Console.WriteLine(k);
k = k + 1;
}
La palabra while va en minúsculas. Dentro de los paréntesis solo se sienta la prueba: k <= 3. Ahí no hay inicio ni paso — a diferencia de la línea for que viste antes. Las llaves guardan la línea de escritura y el paso. Console.WriteLine(k); escribe el número actual sin comillas alrededor de k. Luego k = k + 1; guarda uno más bajo k para que la siguiente prueba pueda volverse false. Guarda el archivo.

El archivo que guardas

Mantén esta forma de enseñanza. Una línea de almacenamiento encima del bucle, int k = 1;. Un while con paréntesis solo alrededor de la prueba. Una línea de escritura dentro de las llaves. Un paso dentro de las llaves, k = k + 1;. No hay encabezado for, no hay contador n de la página anterior y no hay comillas alrededor de k.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca la ejecución. int k = 1; guarda 1. while (k <= 3) pregunta la prueba. Console.WriteLine(k); escribe el k actual. k = k + 1; mueve el contador. Tres líneas en pantalla: 1, luego 2, luego 3. En el archivo que guardas no hay línea for.

Ejecútalo con dotnet run. El programa escribe tres líneas y se detiene. No espera a que escribas. El contador y el while ya estaban en el archivo. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y deja int k = 1; y el while de arriba. La pantalla muestra 1, luego 2, luego 3. Si la pantalla nunca se detiene y sigue escribiendo 1, el paso falta de las llaves. Vuelve a poner k = k + 1; dentro. Si la pantalla muestra una ejecución residual estilo for, borra el encabezado for. Si la pantalla muestra la letra k en cada línea, la línea de escritura tiene comillas: Console.WriteLine("k");. No reinstales el .NET SDK por una pantalla que muestra las líneas equivocadas.

Recorre una ejecución completa en orden. k arranca en 1 antes del while. La prueba k <= 3 es true, así que el cuerpo corre: la línea de escritura escribe 1, luego el paso guarda 2. La prueba sigue siendo true: escribe 2, guarda 3. La prueba sigue siendo true: escribe 3, guarda 4. Ahora k <= 3 es false, así que el bucle termina. El inicio corrió una vez, encima del bucle. La prueba corrió antes de cada pasada. El paso corrió dentro de las llaves después de cada escritura. Esos tres trabajos son las mismas ideas que en for, pero no van empaquetados en una línea de encabezado. Si omites k = k + 1; y dejas k en 1 para siempre, la prueba se queda true y la misma línea puede escribirse sin detenerse — ese caso sin fin es por qué el paso pertenece al cuerpo en esta página.

Amplía la prueba

Cambia solo la prueba para que el bucle llegue un paso más lejos: while (k <= 4). Deja el inicio y el paso como están. Ahora la pantalla debería mostrar cuatro líneas: 1, 2, 3 y 4.

Este es el segundo archivo. No es el que guardas. Ejecuta dotnet run. La pantalla muestra cuatro líneas. No reescribiste la línea de escritura ni el paso — solo cambió la prueba dentro de while (…). Después de ver cuatro líneas, vuelve al archivo guardado: k <= 3 y el mismo cuerpo. Ambas versiones son C# válido. Enseñan la misma forma while con un punto de parada distinto.

Lee otra vez la ejecución de cuatro líneas. k arranca en 1. Cada prueba true escribe el k actual y luego suma 1. Cuando k llega a 5, la prueba falla y el bucle se detiene. El dígito 5 nunca aparece en pantalla en este demo, porque el cuerpo solo corre mientras la prueba sigue siendo true.

Usa la tabla como comprobación después del primer demo, no en lugar de una ejecución. Antes de cada línea de escritura en ese demo, k guarda el número que aparecerá en esa línea. Después de la tercera escritura, el paso guarda 4 y la prueba falla. Si la pantalla nunca se detiene en una versión sin paso, vuelve a poner k = k + 1; dentro de las llaves — no reinstales el .NET SDK.

Reglas que dejan while claro

Los paréntesis alrededor de la prueba son obligatorios. Escribir while k <= 3 { … } sin paréntesis hace que el build escriba un error. El cuerpo de esta página siempre va entre llaves, porque cada pasada tiene dos líneas: la de escritura y el paso. Si dejas el paso después de la llave de cierre, corre una vez cuando el bucle ya terminó — y dentro del bucle k nunca cambia, así que el bucle puede correr para siempre. Mantén el paso dentro de las llaves en ambos demos.

while no es for ni switch. for empaqueta inicio, prueba y paso en una línea de encabezado. while deja sola la prueba en su encabezado y te pide colocar el inicio y el paso tú mismo. switch elige una vez entre etiquetas case. No dejes un bucle for o un switch en el mismo Main y te preguntes por qué la pantalla muestra un resto de encabezado estilo for o la palabra mid. El Main de esta sesión debe guardar solo el int y el while.

Una confusión frecuente es escribir la propia sintaxis: Console.WriteLine("while");. Eso escribe los caracteres while. No repite. Otra confusión es poner comillas alrededor de k: Console.WriteLine("k"); escribe la letra k en cada pasada. Mantén Console.WriteLine(k) sin comillas cuando quieras el contador en pantalla. Si la prueba ya es false cuando se alcanza el while por primera vez — por ejemplo k arranca en 5 y la prueba dice k <= 3 — el cuerpo nunca corre y la pantalla se queda en blanco. Eso sigue siendo un while válido; los demos de esta lección mantienen una prueba que es true al menos una vez para que veas las líneas escritas.

Ya puedes arrancar un contador encima de while, poner una prueba en while (…) y mantener la línea de escritura y el paso dentro de las llaves. Cambiar la prueba cambia cuántas líneas obtienes. La siguiente página es break y continue, donde sales temprano de un bucle o saltas una pasada sin terminar el bucle entero.

La pantalla es el contador que cambia

El archivo que guardas escribe 1, luego 2, luego 3. El nombre k está en la línea de escritura, y la letra k no está en pantalla. El inicio se sienta encima del while, y no está en pantalla. Las comillas alrededor de k o alrededor de while escriben letras, no el camino del contador.