Métodos

Escribe un método llamado ring que escriba una palabra: ding. Pon esas líneas de escritura bajo static void ring() con paréntesis vacíos. Dentro de Main, escribe solo ring(); — el nombre, luego paréntesis vacíos, luego un punto y coma. Ejecuta el programa. La pantalla debería mostrar una línea: ding. Main no guarda el WriteLine de ding. El método sí. Esa separación es lo que enseña esta página. Mantén el nombre de la clase pública Pine.

Líneas que viven bajo ring

Hasta ahora, la mayor parte del trabajo de escritura estaba directamente dentro de Main. Eso sigue funcionando. Un método da a esas mismas líneas un nombre propio. Escribes las líneas una vez bajo ese nombre. Luego Main las pide escribiendo el nombre como llamada.
Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier foreach que recorra plants o slots si esa forma sigue ahí. Borra un for contado con break o continue si todavía está. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura y no tiene un demo de bucle sobrante en Main.
Fuera de Main, aún dentro de las llaves de la clase, escribirás static void ring() con un cuerpo que ejecuta Console.WriteLine("ding");. El programa completo está en el siguiente cuadro para que lo copies limpio.
La palabra static se queda en esta forma para principiantes para que Main pueda llamar ring sin crear un objeto. La palabra void significa que este método no devuelve un valor al llamador — solo ejecuta su cuerpo. El nombre ring es la etiqueta que escribirás en Main. Los paréntesis vacíos () significan que el método de esta página no toma valores de entrada. Las llaves guardan el cuerpo. Guarda el archivo antes de ejecutar.

El archivo que guardas

Aquí está el programa pequeño completo para esta página. Main solo guarda la llamada. ring guarda la línea de escritura. En este archivo guardado no hay contador de índice ni recorrido de array.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde empieza el tiempo de ejecución. La única instrucción en Main es ring();. Debajo de Main, aún dentro de la clase, static void ring() guarda Console.WriteLine("ding");. Una línea en la pantalla: ding.

Ejecútalo con dotnet run. El programa escribe una línea y termina. No espera a que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén ring(); en Main más el método ring de arriba. La pantalla muestra ding. Si la pantalla muestra leaf y mint, un resto de foreach sigue escribiendo. Si la pantalla muestra las letras ring, una línea de escritura tiene comillas alrededor de esa palabra: Console.WriteLine("ring");. No reinstales el SDK de .NET por una pantalla que muestra la línea incorrecta.

Recorre una ejecución completa en orden. C# empieza en Main. La única instrucción en Main es ring();. Esa llamada salta al método ring. Dentro de ring, WriteLine escribe ding. Luego ring termina, y en Main no queda nada, así que el programa termina. En esta página no pusiste Console.WriteLine("ding"); dentro de Main. Lo pusiste bajo ring y lo pediste por nombre. Si la pantalla muestra ding, la llamada llegó al cuerpo. Si la pantalla queda en blanco tras una compilación limpia, Main nunca llamó a ring.
Piensa en ring como un estante etiquetado para las líneas de escritura. Main no necesita repetir esas líneas. Solo necesita el nombre del estante escrito como llamada. Por eso un Main corto aún puede producir una línea clara en pantalla: el trabajo vive bajo el nombre del método, y la llamada es la petición. Cuando ese patrón esté claro, añadir otra llamada es solo otra petición al mismo estante de líneas de escritura.

Llama ring desde Main más de una vez

Cambia solo Main para que llame al mismo método dos veces. Deja el método ring en paz. El cuerpo sigue escribiendo ding una vez por llamada.

Este es el segundo archivo. No es el archivo que guardas para la forma de una llamada, pero enseña el mismo método. Ejecuta dotnet run. La pantalla debería mostrar dos líneas, cada una diciendo ding. La primera llamada ejecuta el cuerpo una vez. La segunda llamada ejecuta el mismo cuerpo otra vez. Esa reutilización es la razón de nombrar las líneas. No copiaste WriteLine una segunda vez bajo ring. Escribiste una segunda llamada en Main.
Si dejas solo un ring();, la pantalla vuelve a un solo ding. La definición del método no escribe por sí sola. Solo una llamada desde Main ejecuta el cuerpo. Un archivo que define ring pero nunca lo llama puede compilar y aun así mostrar una pantalla en blanco al ejecutar. Después de ver dos líneas, vuelve al archivo guardado de una llamada si esa es la forma que quieres guardar: un ring(); en Main.

Piezas del encabezado de un método

En esta página el encabezado es static void ring(). Léelo de izquierda a derecha. static permite que Main llame al método en esta forma para principiantes. void significa que no vuelve ningún valor por la llamada. ring es el nombre. () están vacíos a propósito: esta sesión no pasa palabras ni números al método. La siguiente página, parameters, pone nombres dentro de esos paréntesis. La página siguiente, return, cambia void cuando necesitas un valor de vuelta. Guarda ambos para después. Hoy bastan () vacíos y void.

La llamada en Main debe coincidir exactamente con el nombre: ring(); con r minúscula, paréntesis vacíos y un punto y coma. Escribir Ring(); con R mayúscula es un nombre distinto para C#. Escribir ring sin () no es una llamada en esta forma. Escribir Console.WriteLine("ring"); escribe las cuatro letras de la palabra ring; no ejecuta el cuerpo del método. Mantén la llamada como ring(); cuando quieras ding en la pantalla.

Un resto común es un recorrido antiguo foreach de plants que sigue sentado en Main junto a la nueva llamada. Entonces la pantalla puede mostrar leaf y mint, o 2, 4 y 6, en lugar de ding — o ambos tipos mezclados. Limpia Main hasta las llamadas ring(); que esta lección necesita. Otro error es poner el método dentro de las llaves de Main. Los métodos de esta página se sientan dentro de la clase, junto a Main, no anidados dentro de Main.

foreach de la página anterior recorría valores ya guardados en un array. Esta página no recorre un array. Nombra un método void y lo llama. No dejes foreach (string plant in plants) en el mismo Main y te preguntes por qué la pantalla muestra leaf en lugar de ding. El Main guardado de esta sesión debe guardar solo la llamada ring();. El cuerpo del método guarda la línea de escritura de ding.

Ya puedes escribir static void ring(), poner un WriteLine en sus llaves y llamar ring() desde Main para que la pantalla muestre ding. Llamar dos veces escribe ding dos veces sin copiar el cuerpo. Los paréntesis vacíos y void se quedan en esta página a propósito. La siguiente página es parameters, donde los nombres van dentro de los paréntesis para que el método pueda usar valores que pasas desde Main.

La pantalla es el cuerpo del método

El archivo que guardas escribe ding una vez cuando Main tiene una llamada. El nombre ring está en la llamada, y las letras ring no están en la pantalla como palabra impresa a menos que las hayas puesto entre comillas. Los () vacíos se sientan tanto en el encabezado como en la llamada. Anidar ring dentro de Main no es la forma que construye esta lección.