Rekursion

Schreibe eine Methode namens down, die ein int namens n nimmt. Wenn n 0 oder kleiner ist, stoppe mit einem nackten return;. Sonst schreibe n, und rufe dann down(n - 1) aus derselben Methode auf. Aus Main rufe down(3); auf. Der Bildschirm sollte drei Zeilen zeigen: 3, dann 2, dann 1. Die Methode ruft sich weiter mit einer kleineren Zahl auf, bis der Stopp die Kette beendet. Dieser Selbstaufruf mit Stopp ist das, was diese Seite lehrt. Behalte den öffentlichen Klassennamen Pine.

Eine Methode, die sich selbst aufruft

Auf der Gültigkeitsbereich-Seite lief mark einmal und war fertig. Hier läuft down, und startet dann ein weiteres down mit einem neuen Argument, bevor der erste Aufruf ganz fertig ist. Jeder Aufruf hat sein eigenes n. Die Kette endet erst, wenn ein Aufruf den Stopp trifft.
Öffne die Pine-Datei. Der Klassenname bleibt Pine. Diese Seite benennt den Typ nicht um. Lösche jede übrig gebliebene mark-Demo, falls das noch alles ist, was du in Main hast. Lösche jedes übrig gebliebene paint. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen.
Außerhalb von Main, noch innerhalb der geschweiften Klassenklammern, schreibe static void down(int n). Behalte void auf dieser Seite: jeder Schritt schreibt, und nichts muss über einen typisierten return-Wert zurückkommen. Der Stopp nutzt return; ohne Wert — das beendet nur diesen Aufruf. Speichere die Datei vor dem Lauf. Das erste vollständige Programm steht in der nächsten Box.

Die Datei, die du behältst

Das ist die Version, die du zuerst ausführst. Main hält einen Aufruf. down hält den Stopp, die Schreibzeile und den Selbstaufruf.

Lies von oben. using System; bereitet kurze Namen vor. public class Pine benennt den Typ. public static void Main() ist der Startpunkt der Laufzeit. Der Aufruf down(3) kommt mit n gleich 3 hinein. Das ist größer als 0, also schreibt die Methode 3 und ruft dann down(2) auf. Der zweite Aufruf schreibt 2 und ruft dann down(1) auf. Der dritte Aufruf schreibt 1 und ruft dann down(0) auf. Der Aufruf mit 0 trifft n <= 0 und kehrt ohne Schreiben zurück. Die Kette endet. Drei Zeilen auf dem Bildschirm: 3, dann 2, dann 1.

Führe es mit dotnet run aus. Das Programm schreibt drei Zeilen und stoppt. Es wartet nicht auf deine Eingabe. Wenn dotnet run wartet, ist ReadLine noch in der Datei. Lösche diese Zeile und behalte down(3); plus die down-Methode darüber. Der Bildschirm zeigt 3, dann 2, dann 1. Wenn der Bildschirm nur 4 zeigt, läuft noch ein übrig gebliebener mark(4)-Aufruf. Wenn der Bildschirm die Buchstaben down zeigt, hat eine Schreibzeile Anführungszeichen: Console.WriteLine("down");. Installiere das .NET SDK nicht neu wegen eines Bildschirms mit falschen Zeilen.

Geh einen vollständigen Lauf der Reihe nach durch. C# startet bei Main. Der Aufruf down(3) kommt mit n gleich 3 hinein. Das ist größer als 0, also schreibt die Methode 3 und ruft dann down(2) auf. Der zweite Aufruf schreibt 2 und ruft dann down(1) auf. Der dritte Aufruf schreibt 1 und ruft dann down(0) auf. Der Aufruf mit 0 trifft n <= 0 und kehrt ohne Schreiben zurück. Die Kette endet. Der Bildschirm behält die drei geschriebenen Zeilen.
Jeder dieser Aufrufe ist ein eigener Durchlauf durch denselben Methodentext. Der erste Durchlauf hat nach dem Start von down(2) noch Arbeit — nämlich das Fertigwerden, nachdem der innere Aufruf zurückkehrt. Du schreibst nicht vier verschiedene Methodennamen. Du schreibst eine Methode und lässt das kleinere Argument den Fortschritt zum Stopp tragen.
Wenn du den Start auf down(2); änderst, sollte der Bildschirm 2 dann 1 zeigen. Der Methodenkörper bleibt gleich; nur das erste Argument ändert sich, also ist die Kette kürzer. Start bei down(4); sollte vier Zeilen zeigen: 4, 3, 2, 1. Wieder bleibt der Körper unverändert; nur Main wählt den ersten Wert.

Setze den Stopp zuerst

Der Stopp muss vor der Schreibzeile und vor dem Selbstaufruf geprüft werden. Wenn du zuerst schreibst und n nie prüfst, oder wenn du immer down(n) mit demselben Wert aufrufst, endet das Programm nicht. Behalte den Block if (n <= 0) oben in der Methode in dieser Anfängerform.

Das ist die zweite Datei. Sie lehrt denselben Körper mit einem kürzeren Start. Führe dotnet run aus. Der Bildschirm zeigt 2 dann 1. Der Stopp beendet die Kette immer noch, wenn n 0 erreicht. down(n) statt down(n - 1) zu schreiben sendet dieselbe Zahl wieder und wieder. Dann kann das Programm laufen, bis das System es stoppt. Das kleinere Argument gehört zur Idee: jeder Aufruf muss sich auf den Stopp zubewegen.
Denk an den Stopp als Ausgangstür. Die Schreibzeile ist die Arbeit auf diesem Schritt. Der Selbstaufruf ist der nächste Schritt. Fehlt die Tür, öffnet jeder Schritt einen weiteren Schritt ohne Ende. Nutzt der nächste Schritt dasselbe n, gehst du nie zur Tür. Beide Fehler sehen im Quelltext anders aus, aber beide enden auf dieser Anfängerform nicht sauber. Nachdem du 2 dann 1 gesehen hast, lege die behaltene down(3)-Datei wieder zurück, wenn das die Form ist, die du speichern willst.

Aufrufkette neben dem Bildschirm

Lies einen Startaufruf neben den Zeilen, die er erzeugt. Jede Zeile ist ein Besuch bei down, der noch schreibt.

Ein häufiger Mix-up ist, den Stopp wegzulassen. Dann schreibt jeder Aufruf und ruft für immer wieder auf. Ein anderer Mix-up ist, nach dem rekursiven Aufruf statt davor zu schreiben. Auf dieser Seite kommt die Schreibzeile zuerst, also zählt der Bildschirm rückwärts. Wenn du Console.WriteLine unter down(n - 1) verschiebst, ändert sich die Zeilenreihenfolge — behalte die Schreibzeile über dem Selbstaufruf für den hier gezeigten Countdown.
Der Gültigkeitsbereich der vorherigen Seite zählt noch ein wenig: das n jedes Aufrufs ist der Parameter dieses Aufrufs. Das n des äußeren Aufrufs überschreibt sich nicht, wenn der innere Aufruf läuft. Der innere Aufruf hat ein eigenes n. Wenn der innere Aufruf zurückkehrt, setzt der äußere nach der Zeile nach dem Selbstaufruf fort — und auf dieser Seite ist das einfach das Ende der Methode.
Eine übrig gebliebene mark-Demo kann in derselben Datei sitzen und den Bildschirm verwirren, wenn Main noch mark aufruft. Räume Main auf down(3); oder down(2); auf, während du diese Seite lernst. Verschachtele down nicht in den geschweiften Klammern von Main. Methoden sitzen in der Klasse, neben Main.
Console.WriteLine("down"); in Main zu schreiben schreibt das Wort down. Es startet die Kette nicht. Behalte down(3);, wenn du die drei Countdown-Zeilen willst.

Noch eine Form: der Stopp schreibt nichts

Du hast schon gesehen, dass der Aufruf mit 0 still zurückkehrt. Du kannst auch einen Startwert von 1 üben. Der Bildschirm sollte eine einzelne Zeile zeigen: 1. Dann ist der nächste Aufruf down(0), der stoppt.

Das ist die dritte Datei. Führe dotnet run aus. Der Bildschirm zeigt eine Zeile: 1. Derselbe Methodenkörper deckt down(3), down(2) und down(1) ab. Nur das erste Argument in Main ändert sich. Das reicht für diese Anfängerseite. Tiefere Ideen wie das Zurückgeben einer Summe aus Rekursion warten auf spätere Kurse; hier ist das Ziel der Selbstaufruf, das kleinere Argument und der Stopp.
Wenn der Bildschirm gar nichts zeigt, prüfe, ob Main noch etwas anderes aufruft, oder ob der Stopptest falsch ist — zum Beispiel würde if (n >= 0) vor jedem Schreiben stoppen, wenn du mit positivem n startest. Behalte n <= 0 als stillen Ausgang, und behalte einen positiven Starter in Main, damit mindestens eine Zeile erscheinen kann.

Du kannst down(int n) schreiben, stoppen wenn n 0 oder kleiner ist, n schreiben, dann down(n - 1) aufrufen. Aus Main startet ein Aufruf die ganze Kette. Der Bildschirm zeigt die Countdown-Zeilen. Eine Methode, die sich nie auf den Stopp zubewegt, endet nicht. Die nächste Seite ist classes, wo du Typen mit Feldern jenseits dieser static-Methodenseiten aufbaust.

Der Bildschirm hält den Countdown

Die Datei, die du behältst, schreibt 3, dann 2, dann 1, wenn Main down(3); aufruft. Der Selbstaufruf steckt in down, und die Buchstaben down stehen nicht als gedrucktes Label auf dem Bildschirm, außer du hast sie in Anführungszeichen gesetzt. down in Main zu verschachteln ist nicht die Form, die diese Lektion baut.