Recursão

Escreva um método chamado down que recebe um int chamado n. Se n for 0 ou menos, pare com um return; simples. Caso contrário escreva n, depois chame down(n - 1) de dentro do mesmo método. A partir de Main chame down(3);. A tela deve mostrar três linhas: 3, depois 2, depois 1. O método continua se chamando com um número menor até a parada encerrar a cadeia. Essa auto-chamada com parada é o que esta página ensina. Mantenha a classe pública chamada Pine.

Um método que chama a si mesmo

Na página de escopo, mark rodou uma vez e terminou. Aqui down roda, depois inicia outro down com um novo argumento antes de a primeira chamada estar totalmente concluída. Cada chamada tem o seu próprio n. A cadeia só termina quando uma chamada atinge a parada.
Abra o arquivo Pine. O nome da classe permanece Pine. Esta página não renomeia o tipo. Apague qualquer resto de demo mark se essa forma ainda for tudo o que você tem em Main. Apague qualquer resto paint. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação.
Fora de Main, ainda dentro das chaves da classe, escreva static void down(int n). Mantenha void nesta página: cada passo escreve, e nada precisa voltar por um return tipado. A parada usa return; sem valor — isso só encerra esta chamada. Salve o arquivo antes de executar. O primeiro programa completo está na caixa seguinte.

O arquivo que você guarda

Esta é a versão que você executa primeiro. Main guarda uma chamada. down guarda a parada, a linha de escrita e a auto-chamada.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. A chamada down(3) entra com n igual a 3. Isso é maior que 0, então o método escreve 3, depois chama down(2). Essa segunda chamada escreve 2, depois chama down(1). Essa terceira chamada escreve 1, depois chama down(0). A chamada com 0 encontra if (n <= 0) e retorna sem escrever. A cadeia termina. Três linhas na tela: 3, depois 2, depois 1.

Execute com dotnet run. O programa escreve três linhas e para. Não espera você digitar. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha down(3); mais o método down acima. A tela mostra 3, depois 2, depois 1. Se a tela mostrar só 4, uma chamada mark(4) restante ainda está rodando. Se a tela mostrar as letras down, uma linha de escrita tem aspas: Console.WriteLine("down");. Você não reinstala o SDK .NET por uma tela que mostra as linhas erradas.

Percorra uma execução completa em ordem. C# começa em Main. A chamada down(3) entra com n igual a 3. Isso é maior que 0, então o método escreve 3, depois chama down(2). Essa segunda chamada escreve 2, depois chama down(1). Essa terceira chamada escreve 1, depois chama down(0). A chamada com 0 encontra n <= 0 e retorna sem escrever. A cadeia termina. A tela guarda as três linhas escritas.
Cada uma dessas chamadas é uma passagem separada pelo mesmo texto do método. A primeira passagem ainda tem trabalho esperando depois de iniciar down(2) — a saber, terminar depois que a chamada interna retorna. Você não escreve quatro nomes de método diferentes. Você escreve um método e deixa o argumento menor carregar o progresso até a parada.
Se você mudar o início para down(2);, a tela deve mostrar 2 depois 1. O corpo do método permanece o mesmo; só o primeiro argumento muda, então a cadeia fica mais curta. Começar em down(4); deve mostrar quatro linhas: 4, 3, 2, 1. De novo o corpo não muda; só Main escolhe o primeiro valor.

Coloque a parada primeiro

A parada deve ser checada antes da linha de escrita e antes da auto-chamada. Se você escrever primeiro e nunca testar n, ou se sempre chamar down(n) com o mesmo valor, o programa não termina. Mantenha o bloco if (n <= 0) no topo do método nesta forma iniciante.

Este é o segundo arquivo. Ensina o mesmo corpo com um início mais curto. Execute dotnet run. A tela mostra 2 depois 1. A parada ainda encerra a cadeia quando n chega a 0. Escrever down(n) em vez de down(n - 1) envia o mesmo número de novo e de novo. Então o programa pode rodar até o sistema pará-lo. O argumento menor faz parte da ideia: cada chamada deve avançar até a parada.
Pense na parada como a porta de saída. A linha de escrita é o trabalho deste passo. A auto-chamada é o próximo passo. Se a porta faltar, cada passo abre outro passo sem fim. Se o próximo passo usar o mesmo n, você nunca caminha até a porta. Os dois erros parecem diferentes no fonte, mas os dois se recusam a terminar limpo nesta forma iniciante. Depois de ver 2 depois 1, coloque de volta o arquivo down(3) guardado se essa for a forma que você quer salvar.

Cadeia de chamadas ao lado da tela

Leia uma chamada inicial ao lado das linhas que ela produz. Cada linha da tabela é uma visita a down que ainda escreve.

Uma confusão comum é deixar de fora a parada. Então cada chamada escreve e chama de novo para sempre. Outra confusão é escrever depois da chamada recursiva em vez de antes. Nesta página a linha de escrita vem primeiro, então a tela conta regressiva. Se você mover Console.WriteLine para baixo de down(n - 1), a ordem das linhas muda — mantenha a linha de escrita acima da auto-chamada para a contagem regressiva mostrada aqui.
O escopo da página anterior ainda importa um pouco: o n de cada chamada é o parâmetro dessa chamada. O n da chamada externa não se reescreve quando a chamada interna roda. A chamada interna tem um n separado. Quando a chamada interna retorna, a chamada externa continua na linha depois da auto-chamada — e nesta página isso é simplesmente o fim do método.
Um resto de demo mark pode ficar no mesmo arquivo e confundir a tela se Main ainda chamar mark. Limpe Main até down(3); ou down(2); enquanto aprende esta página. Não aninhe down dentro das chaves de Main. Métodos ficam dentro da classe, ao lado de Main.
Escrever Console.WriteLine("down"); em Main escreve a palavra down. Isso não inicia a cadeia. Mantenha down(3); quando quiser as três linhas da contagem regressiva.

Mais uma forma: a parada não escreve nada

Você já viu que a chamada com 0 retorna em silêncio. Você também pode praticar um valor inicial de 1. A tela deve mostrar uma única linha: 1. Depois a próxima chamada é down(0), que para.

Este é o terceiro arquivo. Execute dotnet run. A tela mostra uma linha: 1. O mesmo corpo de método cobre down(3), down(2) e down(1). Só o primeiro argumento em Main muda. Isso basta para esta página iniciante. Ideias mais profundas como devolver uma soma a partir da recursão esperam cursos posteriores; aqui o objetivo é a auto-chamada, o argumento menor e a parada.
Se a tela não mostrar nada, verifique se Main ainda chama outra coisa, ou se o teste de parada está errado — por exemplo if (n >= 0) pararia antes de qualquer escrita quando você começa com um n positivo. Mantenha n <= 0 como saída silenciosa, e mantenha um início positivo em Main para que pelo menos uma linha possa aparecer.

Você pode escrever down(int n), parar quando n for 0 ou menos, escrever n, depois chamar down(n - 1). A partir de Main, uma chamada inicia a cadeia inteira. A tela mostra as linhas da contagem regressiva. Um método que nunca avança até a parada não termina. A página seguinte é classes, onde você começa a construir tipos com campos além destas páginas de métodos static.

A tela guarda a contagem regressiva

O arquivo que você guarda escreve 3, depois 2, depois 1, quando Main chama down(3);. A auto-chamada fica dentro de down, e as letras down não estão na tela como rótulo impresso a menos que você as tenha colocado entre aspas. Aninhar down dentro de Main não é a forma que esta lição constrói.