Methoden

Schreibe eine Methode namens ring, die ein Wort schreibt: ding. Lege diese Schreibzeilen unter static void ring() mit leeren Klammern. In Main schreibe nur ring(); — den Namen, dann leere Klammern, dann ein Semikolon. Starte das Programm. Der Bildschirm sollte eine Zeile zeigen: ding. Main hält nicht die WriteLine für ding. Die Methode tut das. Diese Trennung lehrt diese Seite. Behalte den öffentlichen Klassennamen Pine.

Zeilen, die unter ring leben

Bisher lag die meiste Schreibarbeit direkt in Main. Das funktioniert weiter. Eine Methode gibt denselben Zeilen einen eigenen Namen. Du schreibst die Zeilen einmal unter diesem Namen. Dann fordert Main sie an, indem es den Namen als Aufruf schreibt.
Öffne die Pine-Datei. Der Klassenname bleibt Pine. Diese Seite benennt den Typ nicht um. Lösche jedes foreach, das plants oder slots durchläuft, falls diese Form noch da ist. Lösche ein gezähltes for mit break oder continue, falls es noch da ist. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen und hat keine übrig gebliebene Schleifen-Demo in Main.
Außerhalb von Main, noch in den geschweiften Klammern der Klasse, schreibst du static void ring() mit einem Rumpf, der Console.WriteLine("ding"); ausführt. Das vollständige Programm steht im nächsten Kasten zum sauberen Kopieren.
Das Wort static bleibt in dieser Anfängerform, damit Main ring ohne Objekt aufrufen kann. Das Wort void bedeutet, dass diese Methode dem Aufrufer keinen Wert zurückgibt — sie führt nur ihren Rumpf aus. Der Name ring ist die Bezeichnung, die du in Main tippst. Die leeren Klammern () bedeuten, dass die Methode dieser Seite keine Werte hereinnimmt. Die geschweiften Klammern halten den Rumpf. Speichere die Datei vor dem Start.

Die Datei, die du behältst

Hier ist das vollständige kleine Programm für diese Seite. Main hält nur den Aufruf. ring hält die Schreibzeile. In dieser behaltenen Datei gibt es keinen Indexzähler und keinen Array-Durchlauf.

Lies es von oben. using System; bereitet kurze Namen vor. public class Pine benennt den Typ. public static void Main() ist der Start der Laufzeit. Die einzige Anweisung in Main ist ring();. Unter Main, noch in der Klasse, hält static void ring() den Aufruf Console.WriteLine("ding");. Eine Zeile auf dem Bildschirm: ding.

Starte mit dotnet run. Das Programm schreibt eine Zeile und endet. Es wartet nicht darauf, dass du tippst. Wenn dotnet run wartet, ist ReadLine noch in der Datei. Lösche diese Zeile und behalte ring(); in Main plus die Methode ring darüber. Der Bildschirm zeigt ding. Wenn der Bildschirm leaf und mint zeigt, schreibt noch ein foreach-Rest. Wenn der Bildschirm die Buchstaben ring zeigt, hat eine Schreibzeile Anführungszeichen um dieses Wort: Console.WriteLine("ring");. Installiere das .NET SDK nicht neu wegen eines Bildschirms mit der falschen Zeile.

Geh einen vollständigen Lauf der Reihe nach durch. C# startet bei Main. Die einzige Anweisung in Main ist ring();. Dieser Aufruf springt in die Methode ring. In ring schreibt WriteLine das Wort ding. Dann endet ring, und in Main bleibt nichts, also endet das Programm. Du hast Console.WriteLine("ding"); auf dieser Seite nicht in Main gelegt. Du hast es unter ring gelegt und per Namen angefordert. Wenn der Bildschirm ding zeigt, hat der Aufruf den Rumpf erreicht. Wenn der Bildschirm nach einem sauberen Build leer bleibt, hat Main ring nie aufgerufen.
Denk an ring als beschriftetes Regal für die Schreibzeilen. Main muss diese Zeilen nicht wiederholen. Es braucht nur den Regalnamen als Aufruf. Deshalb kann ein kurzes Main trotzdem eine klare Bildschirmzeile erzeugen: die Arbeit lebt unter dem Methodennamen, und der Aufruf ist die Anfrage. Sobald dieses Muster klar ist, ist ein weiterer Aufruf nur eine weitere Anfrage an dasselbe Regal von Schreibzeilen.

Rufe ring aus Main mehr als einmal auf

Ändere nur Main, sodass es dieselbe Methode zweimal aufruft. Lass die Methode ring selbst in Ruhe. Der Rumpf schreibt weiterhin einmal ding pro Aufruf.

Das ist die zweite Datei. Es ist nicht die Datei, die du für die Ein-Aufruf-Form behältst, aber sie lehrt dieselbe Methode. Starte dotnet run. Der Bildschirm sollte zwei Zeilen zeigen, jede mit ding. Der erste Aufruf führt den Rumpf einmal aus. Der zweite Aufruf führt denselben Rumpf erneut aus. Diese Wiederverwendung ist der Grund, die Zeilen zu benennen. Du hast WriteLine nicht ein zweites Mal unter ring kopiert. Du hast einen zweiten Aufruf in Main geschrieben.
Wenn du nur ein ring(); lässt, kehrt der Bildschirm zu einem einzelnen ding zurück. Die Methodendefinition schreibt nicht von allein. Nur ein Aufruf aus Main führt den Rumpf aus. Eine Datei, die ring definiert, aber nie aufruft, kann bauen und beim Start trotzdem einen leeren Bildschirm zeigen. Nachdem du zwei Zeilen gesehen hast, setze die behaltene Ein-Aufruf-Datei zurück, wenn das die Form ist, die du speichern willst: ein ring(); in Main.

Teile eines Methoden-Headers

Auf dieser Seite lautet der Header static void ring(). Lies ihn von links nach rechts. static lässt Main die Methode in dieser Anfängerform aufrufen. void bedeutet, dass kein Wert über den Aufruf zurückkommt. ring ist der Name. () sind absichtlich leer: diese Sitzung übergibt keine Wörter oder Zahlen an die Methode. Die nächste Seite, parameters, setzt Namen in diese Klammern. Die Seite danach, return, ändert void, wenn du einen Wert zurück brauchst. Behalte beides für später. Heute reichen leere () und void.

Der Aufruf in Main muss den Namen genau treffen: ring(); mit kleinem r, leeren Klammern und einem Semikolon. Ring(); mit großem R ist für C# ein anderer Name. ring ohne () ist in dieser Form kein Aufruf. Console.WriteLine("ring"); schreibt die vier Buchstaben des Wortes ring; es führt den Methodenkörper nicht aus. Behalte den Aufruf als ring();, wenn du ding auf dem Bildschirm willst.

Ein häufiger Rest ist ein alter foreach-plants-Durchlauf, der noch neben dem neuen Aufruf in Main sitzt. Dann kann der Bildschirm leaf und mint, oder 2, 4 und 6, statt ding zeigen — oder beide Arten gemischt. Räume Main auf die ring();-Aufrufe, die diese Lektion braucht. Eine andere Verwechslung ist, die Methode in die geschweiften Klammern von Main zu setzen. Methoden auf dieser Seite sitzen in der Klasse, neben Main, nicht verschachtelt in Main.

foreach von der vorherigen Seite durchlief Werte, die schon in einem Array lagen. Diese Seite durchläuft kein Array. Sie benennt eine void-Methode und ruft sie auf. Lass foreach (string plant in plants) nicht im selben Main und wundere dich nicht, warum der Bildschirm leaf statt ding zeigt. Das behaltene Main dieser Sitzung soll nur den Aufruf ring(); halten. Der Methodenkörper hält die Schreibzeile für ding.

Du kannst jetzt static void ring() schreiben, ein WriteLine in die geschweiften Klammern setzen und ring() aus Main aufrufen, sodass der Bildschirm ding zeigt. Zweimal aufrufen schreibt ding zweimal, ohne den Rumpf zu kopieren. Leere Klammern und void bleiben auf dieser Seite absichtlich. Die nächste Seite ist parameters, wo Namen in die Klammern kommen, damit die Methode Werte nutzen kann, die du aus Main übergibst.

Der Bildschirm ist der Methodenkörper

Die Datei, die du behältst, schreibt ding einmal, wenn Main einen Aufruf hat. Der Name ring steht im Aufruf, und die Buchstaben ring stehen nicht als gedrucktes Wort auf dem Bildschirm, es sei denn, du hast sie in Anführungszeichen gesetzt. Leere () sitzen sowohl am Header als auch am Aufruf. ring in Main zu verschachteln ist nicht die Form, die diese Lektion baut.