Recursión

Escribe un método llamado down que tome un int llamado n. Si n es 0 o menos, para con un return; desnudo. Si no, escribe n y luego llama down(n - 1) desde el mismo método. Desde Main llama down(3);. La pantalla debería mostrar tres líneas: 3, luego 2, luego 1. El método sigue llamándose a sí mismo con un número más pequeño hasta que la parada termina la cadena. Esa autollamada con parada es lo que enseña esta página. Mantén el nombre de la clase pública Pine.

Un método que se llama a sí mismo

En la página de ámbito, mark corrió una vez y terminó. Aquí down corre y luego arranca otro down con un argumento nuevo antes de que la primera llamada termine del todo. Cada llamada tiene su propio n. La cadena solo termina cuando una llamada alcanza la parada.
Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier demo mark sobrante si esa forma es todo lo que aún tienes en Main. Borra cualquier resto de paint. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura.
Fuera de Main, todavía dentro de las llaves de la clase, escribe static void down(int n). Mantén void en esta página: cada paso escribe, y nada necesita volver por un return tipado. La parada usa return; sin valor — solo termina esta llamada. Guarda el archivo antes de ejecutar. El primer programa completo está en la caja siguiente.

El archivo que guardas

Esta es la versión que ejecutas primero. Main guarda una llamada. down guarda la parada, la línea de escritura y la autollamada.

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. La llamada down(3) entra con n igual a 3. Eso es mayor que 0, así que el método escribe 3 y luego llama down(2). Esa segunda llamada escribe 2 y luego llama down(1). Esa tercera llamada escribe 1 y luego llama down(0). La llamada con 0 choca con n <= 0 y vuelve sin escribir. La cadena termina. Tres líneas en la pantalla: 3, luego 2, luego 1.

Ejecútalo con dotnet run. El programa escribe tres líneas y para. No espera a que tú escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén down(3); más el método down de arriba. La pantalla muestra 3, luego 2, luego 1. Si la pantalla muestra solo 4, aún corre una llamada sobrante mark(4). Si la pantalla muestra las letras down, una línea de escritura tiene comillas: Console.WriteLine("down");. No reinstales el SDK de .NET por una pantalla que muestra las líneas incorrectas.

Recorre una ejecución completa en orden. C# empieza en Main. La llamada down(3) entra con n igual a 3. Eso es mayor que 0, así que el método escribe 3 y luego llama down(2). Esa segunda llamada escribe 2 y luego llama down(1). Esa tercera llamada escribe 1 y luego llama down(0). La llamada con 0 choca con n <= 0 y vuelve sin escribir. La cadena termina. La pantalla conserva las tres líneas escritas.
Cada una de esas llamadas es un paso separado por el mismo texto del método. El primer paso aún tiene trabajo después de arrancar down(2) — a saber, terminar cuando la llamada interior vuelva. No escribes cuatro nombres de método distintos. Escribes un método y dejas que el argumento más pequeño lleve el avance hacia la parada.
Si cambias el inicio a down(2);, la pantalla debería mostrar 2 luego 1. El cuerpo del método se queda igual; solo cambia el primer argumento, así que la cadena es más corta. Empezar en down(4); debería mostrar cuatro líneas: 4, 3, 2, 1. Otra vez el cuerpo no cambia; solo Main elige el primer valor.

Pon la parada primero

La parada debe comprobarse antes de la línea de escritura y antes de la autollamada. Si escribes primero y nunca pruebas n, o si siempre llamas down(n) con el mismo valor, el programa no termina. Mantén el bloque if (n <= 0) arriba del método en esta forma para principiantes.

Este es el segundo archivo. Enseña el mismo cuerpo con un inicio más corto. Ejecuta dotnet run. La pantalla muestra 2 luego 1. La parada sigue terminando la cadena cuando n llega a 0. Escribir down(n) en lugar de down(n - 1) envía el mismo número una y otra vez. Entonces el programa puede correr hasta que el sistema lo detenga. El argumento más pequeño forma parte de la idea: cada llamada debe moverse hacia la parada.
Piensa en la parada como la puerta de salida. La línea de escritura es el trabajo de este paso. La autollamada es el siguiente paso. Si falta la puerta, cada paso abre otro paso sin fin. Si el siguiente paso usa el mismo n, nunca caminas hacia la puerta. Ambos errores se ven distintos en el código fuente, pero ambos se niegan a terminar limpio en esta forma para principiantes. Después de ver 2 luego 1, vuelve a poner el archivo guardado con down(3) si esa es la forma que quieres conservar.

Cadena de llamadas junto a la pantalla

Lee una llamada de inicio junto a las líneas que produce. Cada fila es una visita a down que aún escribe.

Una confusión común es omitir la parada. Entonces cada llamada escribe y vuelve a llamar para siempre. Otra confusión es escribir después de la llamada recursiva en lugar de antes. En esta página la línea de escritura va primero, así que la pantalla cuenta hacia atrás. Si mueves Console.WriteLine debajo de down(n - 1), el orden de las líneas cambia — mantén la línea de escritura encima de la autollamada para la cuenta atrás mostrada aquí.
El ámbito de la página anterior aún importa un poco: el n de cada llamada es el parámetro de esa llamada. El n de la llamada exterior no se reescribe cuando corre la llamada interior. La llamada interior tiene un n aparte. Cuando la llamada interior vuelve, la exterior continúa desde la línea después de la autollamada — y en esta página eso es simplemente el final del método.
Una demo mark sobrante puede quedarse en el mismo archivo y confundir la pantalla si Main aún llama mark. Deja Main en down(3); o down(2); mientras aprendes esta página. No anides down dentro de las llaves de Main. Los métodos viven dentro de la clase, junto a Main.
Escribir Console.WriteLine("down"); en Main escribe la palabra down. No arranca la cadena. Mantén down(3); cuando quieras las tres líneas de cuenta atrás.

Una forma más: la parada no escribe nada

Ya viste que la llamada con 0 vuelve en silencio. También puedes practicar un valor de inicio de 1. La pantalla debería mostrar una sola línea: 1. Luego la siguiente llamada es down(0), que para.

Este es el tercer archivo. Ejecuta dotnet run. La pantalla muestra una línea: 1. El mismo cuerpo del método cubre down(3), down(2) y down(1). Solo cambia el primer argumento en Main. Eso basta para esta página de principiante. Ideas más profundas como devolver una suma desde la recursión esperan cursos posteriores; aquí el objetivo es la autollamada, el argumento más pequeño y la parada.
Si la pantalla no muestra nada en absoluto, comprueba si Main aún llama otra cosa, o si la prueba de parada está mal — por ejemplo if (n >= 0) pararía antes de cualquier escritura cuando empiezas con un n positivo. Mantén n <= 0 como salida silenciosa, y mantén un inicio positivo en Main para que pueda aparecer al menos una línea.

Puedes escribir down(int n), parar cuando n es 0 o menos, escribir n y luego llamar down(n - 1). Desde Main, una llamada arranca toda la cadena. La pantalla muestra las líneas de cuenta atrás. Un método que nunca se mueve hacia la parada no termina. La página siguiente es classes, donde empiezas a construir tipos con campos más allá de estas páginas de métodos static.

La pantalla guarda la cuenta atrás

El archivo que guardas escribe 3, luego 2, luego 1, cuando Main llama down(3);. La autollamada está dentro de down, y las letras down no están en la pantalla como etiqueta impresa a menos que las hayas entrecomillado. Anidar down dentro de Main no es la forma que construye esta lección.