foreach

string[] plants = { "leaf", "mint" }; guarda dos palabras. Luego foreach (string plant in plants) entrega cada palabra al nombre plant, y Console.WriteLine(plant) la escribe. La pantalla muestra dos líneas: leaf, luego mint. En esta página no escribes un contador de índice. Mantén el nombre de la clase pública Pine.

Un nombre para cada valor del array

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier for con break o continue si esa forma sigue ahí. Borra un for contado como for (int i = 1; i <= 5; i = i + 1) si todavía está. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura, no tiene break temprano y no tiene contador de índice. La pantalla solo la escribe la línea de escritura dentro de las llaves de foreach.

Dentro de Main, guarda primero el array: string[] plants = { "leaf", "mint" };. Esa línea no escribe la pantalla. Solo guarda dos palabras bajo el nombre plants. Luego el bucle:
foreach (string plant in plants) {
Console.WriteLine(plant);
}
La palabra foreach va en minúsculas, escrita como una sola palabra. Dentro de los paréntesis van el tipo del elemento string, el nombre plant para un elemento, la palabra in y luego el nombre del array plants. Ese in no es una ruta ni una etiqueta case. Marca «cada valor de plants entra en plant.» Las llaves llevan el cuerpo. Console.WriteLine(plant); escribe la palabra actual sin comillas alrededor de plant. Guarda el archivo.

El archivo que guardas

Mantén esta forma de enseñanza. Un string[] llamado plants que guarda leaf y luego mint. Un foreach con string plant in plants. Una línea de escritura que escribe el nombre desnudo plant. No hay índice i, ni break, ni comillas alrededor de plant.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el tiempo de ejecución. string[] plants = { "leaf", "mint" }; guarda dos palabras. foreach (string plant in plants) las recorre. Console.WriteLine(plant); escribe cada palabra. Dos líneas en pantalla: leaf, luego mint.

Ejecútalo con dotnet run. El programa escribe dos líneas y se detiene. No espera a que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén el array más el foreach de arriba. La pantalla muestra leaf, luego mint. Si la pantalla muestra solo leaf, quizá sigues en la página de arrays que escribe plants[0] una vez. Sustituye eso por foreach. Si la pantalla muestra las letras plant en cada línea, la línea de escritura lleva comillas: Console.WriteLine("plant");. Si la pantalla muestra foreach como letras, una línea de escritura pone comillas alrededor de esa palabra. No reinstales el SDK de .NET por una pantalla con líneas incorrectas.

Recorre una ejecución completa en orden. plants guarda leaf, luego mint. La primera pasada pone plant en leaf y la línea de escritura escribe leaf. La segunda pasada pone plant en mint y escribe mint. Luego no quedan valores, así que el bucle termina. En esta página no escribiste int i = 0 ni i < plants.Length. El encabezado de foreach pide a C# visitar cada valor guardado una vez. El nombre plant se declara una vez en el encabezado como string plant.

Recorre un array int de la misma forma

Cambia el array guardado y el tipo del elemento para que cada valor sea un número entero. Usa int[] slots = { 2, 4, 6 }; y foreach (int n in slots) con Console.WriteLine(n); en el cuerpo. Ahora la pantalla debe mostrar tres líneas: 2, luego 4, luego 6. La palabra in sigue entre el nombre del elemento y el nombre del array. El cuerpo sigue escribiendo el nombre que guarda un elemento.

Este es el segundo archivo. No es el archivo que guardas. Ejecuta dotnet run. La pantalla muestra tres líneas. Sustituiste el array string por un array int y alineaste el tipo del nombre del elemento con int. Después de ver 2, 4 y 6, vuelve a poner el archivo guardado: plants con foreach (string plant in plants). Ambas versiones son C# válido. Enseñan la misma forma de foreach con tipos de elemento distintos.

Lee otra vez la ejecución int. slots guarda 2, luego 4, luego 6. La primera pasada pone n en 2 y lo escribe. La segunda pasada pone n en 4 y lo escribe. La tercera pasada pone n en 6 y lo escribe. Luego el bucle termina. No hay comillas alrededor de los números en las llaves del array. Console.WriteLine(n) sin comillas alrededor de n escribe esos números guardados en la pantalla.

Reglas que mantienen foreach claro

Los paréntesis deben llevar tipo, nombre, in y nombre del array en ese orden. Escribir foreach (string plant plants) sin in hace que la compilación escriba un error. El tipo del elemento debe encajar con el array: string con un array string, int con un array int. Poner string plant junto a un array int[] no es la forma que construye esta lección. Las llaves siguen llevando el cuerpo cuando el cuerpo tiene una o más líneas.

foreach no es el for contado de la página anterior, ni el break de la página previa. El for contado escribió inicio, prueba y paso con un contador. foreach recorre valores ya guardados en un array. break termina un bucle antes; el primer demo de esta página escribe cada valor. No dejes un demo de break ni un while simple en el mismo Main y te preguntes por qué la pantalla muestra 1 y 2 en lugar de leaf y mint. El Main de esta sesión debe llevar solo el array y el foreach.

Una confusión común es escribir la propia sintaxis: Console.WriteLine("foreach");. Eso escribe los caracteres foreach. No recorre el array. Otra confusión es Console.WriteLine("plant"); con comillas, que escribe la palabra plant en cada pasada en lugar de leaf y mint. Mantén Console.WriteLine(plant) sin comillas cuando quieras el valor del elemento en la pantalla.

Si el array no tiene elementos — por ejemplo string[] plants = { }; — el cuerpo nunca corre y la pantalla queda en blanco. Eso sigue siendo un foreach válido; los demos de esta lección guardan al menos dos valores para que veas las líneas escritas. Cuando más adelante necesites un número de índice en la pantalla, vuelve el for contado; foreach sirve para visitar valores sin gestionar ese índice tú mismo. Cambiar un valor dentro del bucle con plant = "stem"; no reescribe la ranura del array en esta forma para principiantes — trata plant como el valor que lees para escribir, no como una herramienta para editar plants.

Ya puedes guardar un array, escribir foreach (Type name in arrayName) y escribir cada valor una vez. Alinear el tipo del elemento con el array mantiene el bucle compilable. La página siguiente es methods, donde agrupas líneas bajo un nombre que puedes llamar desde Main.

La pantalla es cada valor del array

El archivo que guardas escribe leaf, luego mint. El nombre plant está en la línea de escritura, y las letras plant no aparecen en la pantalla como etiqueta. La palabra in está en los paréntesis, e in no está en la pantalla. Comillas alrededor de plant o alrededor de foreach escriben letras, no el recorrido del array.