Récursivité

Écrivez une méthode nommée down qui prend un int nommé n. Si n vaut 0 ou moins, arrêtez avec un simple return;. Sinon écrivez n, puis appelez down(n - 1) depuis l'intérieur de la même méthode. Depuis Main appelez down(3);. L'écran doit montrer trois lignes : 3, puis 2, puis 1. La méthode continue de s'appeler avec un nombre plus petit jusqu'à ce que le stop termine la chaîne. Cet auto-appel avec un stop est ce que cette page enseigne. Gardez la classe publique nommée Pine.

Une méthode qui s'appelle elle-même

Sur la page de portée, mark s'exécutait une fois et se terminait. Ici down s'exécute, puis démarre un autre down avec un nouvel argument avant que le premier appel soit entièrement terminé. Chaque appel a son propre n. La chaîne ne se termine que lorsqu'un appel atteint le stop.
Ouvrez le fichier Pine. Le nom de classe reste Pine. Cette page ne renomme pas le type. Supprimez tout reste de démo mark si cette forme est encore tout ce que vous avez dans Main. Supprimez tout reste paint. Supprimez toute ligne ReadLine. Le fichier que vous gardez n'attend pas de frappe.
Hors de Main, toujours à l'intérieur des accolades de la classe, écrivez static void down(int n). Gardez void sur cette page : chaque étape écrit, et rien n'a besoin de revenir par un return typé. Le stop utilise return; sans valeur — cela termine seulement cet appel. Enregistrez le fichier avant d'exécuter. Le premier programme complet est dans la boîte suivante.

Le fichier que vous gardez

C'est la version que vous exécutez en premier. Main tient un appel. down tient le stop, la ligne d'écriture, et l'auto-appel.

Lisez-le du haut. using System; prépare les noms courts. public class Pine nomme le type. public static void Main() est où le runtime démarre. L'appel down(3) entre avec n égal à 3. C'est plus grand que 0, donc la méthode écrit 3, puis appelle down(2). Ce deuxième appel écrit 2, puis appelle down(1). Ce troisième appel écrit 1, puis appelle down(0). L'appel avec 0 frappe if (n <= 0) et revient sans écrire. La chaîne se termine. Trois lignes à l'écran : 3, puis 2, puis 1.

Exécutez avec dotnet run. Le programme écrit trois lignes et s'arrête. Il n'attend pas que vous tapiez. Si dotnet run attend, ReadLine est encore dans le fichier. Supprimez cette ligne et gardez down(3); plus la méthode down ci-dessus. L'écran montre 3, puis 2, puis 1. Si l'écran montre seulement 4, un appel mark(4) restant tourne encore. Si l'écran montre les lettres down, une ligne d'écriture a des guillemets : Console.WriteLine("down");. Vous ne réinstallez pas le SDK .NET pour un écran qui montre les mauvaises lignes.

Parcourez une exécution complète dans l'ordre. C# démarre à Main. L'appel down(3) entre avec n égal à 3. C'est plus grand que 0, donc la méthode écrit 3, puis appelle down(2). Ce deuxième appel écrit 2, puis appelle down(1). Ce troisième appel écrit 1, puis appelle down(0). L'appel avec 0 frappe n <= 0 et revient sans écrire. La chaîne se termine. L'écran garde les trois lignes écrites.
Chacun de ces appels est un passage séparé dans le même texte de méthode. Le premier passage a encore du travail en attente après avoir démarré down(2) — à savoir finir après le retour de l'appel intérieur. Vous n'écrivez pas quatre noms de méthode différents. Vous écrivez une méthode et laissez l'argument plus petit porter le progrès vers le stop.
Si vous changez le départ en down(2);, l'écran doit montrer 2 puis 1. Le corps de la méthode reste le même ; seul le premier argument change, donc la chaîne est plus courte. Partir de down(4); doit montrer quatre lignes : 4, 3, 2, 1. Encore une fois le corps est inchangé ; seul Main choisit la première valeur.

Mettez le stop en premier

Le stop doit être vérifié avant la ligne d'écriture et avant l'auto-appel. Si vous écrivez d'abord et ne testez jamais n, ou si vous appelez toujours down(n) avec la même valeur, le programme ne se termine pas. Gardez le bloc if (n <= 0) en haut de la méthode sur cette forme débutant.

C'est le deuxième fichier. Il enseigne le même corps avec un départ plus court. Exécutez dotnet run. L'écran montre 2 puis 1. Le stop termine encore la chaîne quand n atteint 0. Écrire down(n) au lieu de down(n - 1) renvoie le même nombre encore et encore. Alors le programme peut tourner jusqu'à ce que le système l'arrête. L'argument plus petit fait partie de l'idée : chaque appel doit avancer vers le stop.
Pensez au stop comme à la porte de sortie. La ligne d'écriture est le travail de cette étape. L'auto-appel est l'étape suivante. Si la porte manque, chaque étape ouvre une autre étape sans fin. Si l'étape suivante utilise le même n, vous ne marchez jamais vers la porte. Les deux erreurs ont l'air différentes dans le source, mais toutes les deux refusent de terminer proprement sur cette forme débutant. Après avoir vu 2 puis 1, remettez le fichier down(3) gardé si c'est la forme que vous voulez sauvegarder.

Chaîne d'appels à côté de l'écran

Lisez un appel de départ à côté des lignes qu'il produit. Chaque ligne du tableau est une visite à down qui écrit encore.

Une confusion courante est d'oublier le stop. Alors chaque appel écrit et appelle encore pour toujours. Une autre confusion est d'écrire après l'appel récursif au lieu d'avant. Sur cette page la ligne d'écriture vient d'abord, donc l'écran compte à rebours. Si vous déplacez Console.WriteLine sous down(n - 1), l'ordre des lignes change — gardez la ligne d'écriture au-dessus de l'auto-appel pour le compte à rebours montré ici.
La portée de la page précédente compte encore un peu : le n de chaque appel est le paramètre de cet appel. Le n de l'appel extérieur ne se réécrit pas quand l'appel intérieur tourne. L'appel intérieur a un n séparé. Quand l'appel intérieur revient, l'appel extérieur continue à la ligne après l'auto-appel — et sur cette page c'est simplement la fin de la méthode.
Un reste de démo mark peut rester dans le même fichier et brouiller l'écran si Main appelle encore mark. Nettoyez Main jusqu'à down(3); ou down(2); pendant que vous apprenez cette page. Ne nidez pas down dans les accolades de Main. Les méthodes sont dans la classe, à côté de Main.
Écrire Console.WriteLine("down"); dans Main écrit le mot down. Cela ne démarre pas la chaîne. Gardez down(3); quand vous voulez les trois lignes du compte à rebours.

Une forme de plus : le stop n'écrit rien

Vous avez déjà vu que l'appel avec 0 revient sans bruit. Vous pouvez aussi pratiquer une valeur de départ de 1. L'écran doit montrer une seule ligne : 1. Ensuite l'appel suivant est down(0), qui s'arrête.

C'est le troisième fichier. Exécutez dotnet run. L'écran montre une ligne : 1. Le même corps de méthode couvre down(3), down(2), et down(1). Seul le premier argument dans Main change. Cela suffit pour cette page débutant. Des idées plus profondes comme renvoyer une somme depuis la récursivité attendent des cours plus tard ; ici le but est l'auto-appel, l'argument plus petit, et le stop.
Si l'écran ne montre rien du tout, vérifiez si Main appelle encore autre chose, ou si le test de stop est faux — par exemple if (n >= 0) s'arrêterait avant toute écriture quand vous partez avec un n positif. Gardez n <= 0 comme sortie silencieuse, et gardez un départ positif dans Main pour qu'au moins une ligne puisse apparaître.

Vous pouvez écrire down(int n), vous arrêter quand n vaut 0 ou moins, écrire n, puis appeler down(n - 1). Depuis Main, un appel démarre toute la chaîne. L'écran montre les lignes du compte à rebours. Une méthode qui n'avance jamais vers le stop ne se termine pas. La page suivante est classes, où vous commencez à construire des types avec des champs au-delà de ces pages de méthodes static.

L'écran tient le compte à rebours

Le fichier que vous gardez écrit 3, puis 2, puis 1, quand Main appelle down(3);. L'auto-appel est à l'intérieur de down, et les lettres down ne sont pas à l'écran comme étiquette imprimée sauf si vous les avez mises entre guillemets. Nider down dans Main n'est pas la forme que cette leçon construit.