Gültigkeitsbereich

Schreibe eine Methode namens mark mit einem Parameter: static void mark(int n). Innerhalb der geschweiften Klammern schreibe diesen Parameter mit Console.WriteLine(n);. Aus Main rufe mark(4); auf. Der Bildschirm sollte eine Zeile zeigen: 4. Der Name n existiert nur innerhalb von mark. Wenn du versuchst, n aus Main zu schreiben, lehnt der Build ab. Diese Grenze — welche Namen eine Methode sehen kann — ist das, was diese Seite lehrt. Behalte den öffentlichen Klassennamen Pine.

Namen, die in einer Methode bleiben

Auf der Überladungsseite teilten mehrere paint-Methoden einen Namen, behielten aber getrennte Parameterlisten. Hier ist der Fokus kleiner: eine Methode, ein Parametername und wo dieser Name erscheinen darf. Ein Parameter ist ein Name, der der Methode gehört, die ihn deklariert. Außerhalb der geschweiften Klammern dieser Methode ist der Name weg.
Öffne die Pine-Datei. Der Klassenname bleibt Pine. Diese Seite benennt den Typ nicht um. Lösche jede übrig gebliebene paint-Demo, falls das noch alles ist, was du in Main hast. Lösche jedes übrig gebliebene twice. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Tippen.
Außerhalb von Main, noch in den geschweiften Klammern der Klasse, schreibe static void mark(int n). Der Rumpf hat eine Schreibzeile: Console.WriteLine(n);. Behalte auf dieser Seite void. Du beobachtest Sichtbarkeit, nicht Rückgabewerte. Speichere die Datei vor dem Start. Das vollständige erste Programm steht im nächsten Kasten.

Die Datei, die du behältst

Das ist die Version, die du zuerst startest. Main hält den Aufruf. mark hält die Schreibzeile, die n nutzt.

Lies von oben. using System; bereitet kurze Namen vor. public class Pine benennt den Typ. public static void Main() ist, wo die Laufzeit startet. Der Aufruf mark(4) sendet 4 in den Parameter n. Innerhalb von mark schreibt Console.WriteLine(n) die 4. Wenn mark endet, ist der Name n ebenfalls zu Ende. Main hat nie einen Namen n gehalten. Die Zahl 4 hat den Aufruf als Wert überquert. Der Name n ist nicht nach Main gewandert. Eine Zeile auf dem Bildschirm: 4.

Starte mit dotnet run. Das Programm schreibt eine Zeile und stoppt. Es wartet nicht darauf, dass du tippst. Wenn dotnet run wartet, ist ReadLine noch in der Datei. Lösche diese Zeile und behalte mark(4); plus die mark-Methode oben. Der Bildschirm zeigt 4. Wenn der Bildschirm ok zeigt, läuft noch ein übrig gebliebener paint("ok")-Aufruf. Wenn der Bildschirm den Buchstaben n zeigt, hat eine Schreibzeile Anführungszeichen: Console.WriteLine("n");. Du installierst 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. Der Aufruf mark(4) sendet 4 in den Parameter n. Innerhalb von mark schreibt WriteLine(n) die 4. Wenn mark endet, ist der Name n ebenfalls zu Ende. Main hat nie einen Namen n gehalten. Die Zahl 4 hat den Aufruf als Wert überquert. Der Name n ist nicht nach Main gewandert.
Wenn du Console.WriteLine(n); innerhalb von Main nach dem Aufruf hinzufügst, meldet der Build, dass er den Namen n nicht finden kann. Dieser Fehler ist die Lektion in Aktion: n wurde nie in Main deklariert. Behebe das, indem du diese Zeile aus Main entfernst, oder indem du einen anderen Namen in Main deklarierst, falls du dort ein Lokal brauchst. Erwarte nicht, dass der Parameter von mark von allein in Main erscheint.

Ein lokaler Name neben dem Parameter

Innerhalb von mark kannst du auch einen neuen Namen deklarieren, der kein Parameter ist. Dieser lokale Name lebt nur zwischen den geschweiften Klammern von mark. Eine häufige Anfängerhoffnung ist, dass ein in Main deklarierter Name automatisch in jeder Methode der Klasse sichtbar ist. Das ist bei diesem Aufbau nicht so. Wenn Main int room = 4; hat und mark versucht, room zu schreiben, ohne es zu empfangen, findet der Build room innerhalb von mark nicht. Die Lösung ist, den Wert zu übergeben: mark(room); mit mark weiterhin als mark(int n) deklariert.

Ein Main-Lokal an mark übergeben

Deklariere int room = 4; innerhalb von Main. Rufe mark(room); auf. Innerhalb von mark schreibe weiter n. Der Bildschirm zeigt weiterhin 4. Der lokale Name in Main ist room. Der Parametername in mark ist n. Es sind unterschiedliche Namen an unterschiedlichen Orten. Der Wert 4 ist das, was reist.

Das ist die zweite Datei. Sie lehrt dieselbe Sichtbarkeit mit einem Lokal in Main. Starte dotnet run. Du siehst weiterhin eine Zeile: 4. Wenn du room auf 9 änderst und den Methodenrumpf allein lässt, zeigt der Bildschirm 9. Die Methode schreibt weiterhin, welcher Wert in n angekommen ist. Main kann room auch schreiben, wenn du Console.WriteLine(room); in Main hinzufügst — dieser Name gehört dorthin. Main kann weiterhin n nicht schreiben. Nachdem du die room-Form gesehen hast, setze die behaltene Ein-Aufruf-Datei zurück, falls das die Form ist, die du speichern willst: mark(4); in Main.
Wenn mark ein eigenes Lokal deklariert — zum Beispiel int tag = 1; innerhalb der Klammern — ist dieses tag für Main unsichtbar. Der Versuch Console.WriteLine(tag); in Main scheitert aus demselben Grund, aus dem Schreiben von n aus Main scheitert. Die geschweiften Klammern von mark sind eine Wand für Namen, die darin deklariert sind.

Was die Wand schützt

Lies die Trennung in einfachen Worten. In Main deklarierte Namen bleiben in Main, es sei denn, du übergibst ihre Werte in einen Aufruf. In mark deklarierte Namen — Parameter und Lokale — bleiben in mark. Der Aufruf trägt Werte, nicht die Namen selbst. Überladung von der vorherigen Seite ist eine andere Fähigkeit: mehrere Methoden mit einem gemeinsamen Methodennamen. Gültigkeitsbereich geht darum, wo ein Variablen- oder Parametername im Quelltext erscheinen darf.
Eine übrig gebliebene paint-Demo kann in derselben Datei sitzen und den Bildschirm verwirren, wenn Main noch paint("ok") aufruft. Räume Main auf den mark-Aufruf auf, den du testest. Verschachtele mark nicht innerhalb der Klammern von Main. Methoden sitzen in der Klasse, neben Main.
Console.WriteLine("n"); in Main zu schreiben schreibt den Buchstaben n in Anführungszeichen. Es schreibt nicht den Parameter. Behalte Console.WriteLine(n) innerhalb von mark, wenn du den Wert willst, der durch den Aufruf angekommen ist. mark(); mit leeren Klammern zu schreiben scheitert, wenn der Header noch mark(int n) sagt — der Aufruf muss ein int senden, ob ein Literal wie 4 oder ein Lokal wie room.

Du kannst mark(int n) schreiben, n innerhalb dieser Methode schreiben und n aus Main heraushalten. Du kannst room in Main deklarieren und room an mark übergeben. Der Bildschirm zeigt den Wert, der den Aufruf überquert hat. Namen sickern nicht von allein durch die Klammern. Die nächste Seite ist recursion, wo eine Methode sich selbst mit einem kleineren Argument aufruft, bis eine Stoppbedingung die Kette beendet.

Der Bildschirm hält den Wert, der überquert hat

Die Datei, die du behältst, schreibt 4, wenn Main mark(4); aufruft. Der Name n steht in der Schreibzeile innerhalb von mark, und der Buchstabe n steht nicht als gedrucktes Etikett auf dem Bildschirm, es sei denn, du hast ihn in Anführungszeichen gesetzt. mark innerhalb von Main zu verschachteln ist nicht der Aufbau, den diese Lektion baut.