Ámbito

Escribe un método llamado mark con un parámetro: static void mark(int n). Dentro de las llaves escribe ese parámetro con Console.WriteLine(n);. Desde Main llama mark(4);. La pantalla debería mostrar una línea: 4. El nombre n existe solo dentro de mark. Si intentas escribir n desde Main, la compilación se niega. Ese límite — qué nombres puede ver un método — es lo que enseña esta página. Mantén el nombre de la clase pública Pine.

Nombres que se quedan dentro de un método

En la página de sobrecarga, varios métodos paint compartían un nombre pero mantenían listas de parámetros separadas. Aquí el foco es más pequeño: un método, un nombre de parámetro y dónde se permite que aparezca ese nombre. Un parámetro es un nombre que pertenece al método que lo declara. Fuera de las llaves de ese método, el nombre desaparece.
Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier demo paint sobrante si esa forma es todo lo que aún tienes en Main. Borra cualquier resto de twice. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura.
Fuera de Main, aún dentro de las llaves de la clase, escribe static void mark(int n). El cuerpo tiene una línea de escritura: Console.WriteLine(n);. Mantén void en esta página. Estás mirando la visibilidad, no los valores de retorno. Guarda el archivo antes de ejecutar. El primer programa completo está en el siguiente cuadro.

El archivo que guardas

Esta es la versión que ejecutas primero. Main guarda la llamada. mark guarda la línea de escritura que usa n.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el tiempo de ejecución. La llamada mark(4) envía 4 al parámetro n. Dentro de mark, Console.WriteLine(n) escribe 4. Cuando mark termina, el nombre n también termina. Main nunca tuvo un nombre n. El número 4 cruzó la llamada como valor. El nombre n no se movió a Main. Una línea en la pantalla: 4.

Ejecútalo con dotnet run. El programa escribe una línea y se detiene. No espera a que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y mantén mark(4); más el método mark de arriba. La pantalla muestra 4. Si la pantalla muestra ok, aún corre una llamada sobrante paint("ok"). Si la pantalla muestra la letra n, una línea de escritura tiene comillas: Console.WriteLine("n");. No reinstalas el SDK de .NET por una pantalla que muestra la línea incorrecta.

Recorre una ejecución completa en orden. C# empieza en Main. La llamada mark(4) envía 4 al parámetro n. Dentro de mark, WriteLine(n) escribe 4. Cuando mark termina, el nombre n también termina. Main nunca tuvo un nombre n. El número 4 cruzó la llamada como valor. El nombre n no se movió a Main.
Si añades Console.WriteLine(n); dentro de Main después de la llamada, la compilación informa que no encuentra el nombre n. Ese error es la lección en marcha: n nunca se declaró en Main. Arréglalo quitando esa línea de Main, o declarando un nombre distinto en Main si necesitas un local ahí. No esperes que el parámetro de mark aparezca solo en Main.

Un nombre local junto al parámetro

Dentro de mark también puedes declarar un nombre nuevo que no es un parámetro. Ese nombre local vive solo entre las llaves de mark. Una esperanza frecuente de principiante es que un nombre declarado en Main sea visible automáticamente dentro de cada método de la clase. No lo es, en esta forma. Si Main tiene int room = 4; y mark intenta escribir room sin recibirlo, la compilación no encuentra room dentro de mark. La solución es pasar el valor: mark(room); con mark aún declarado como mark(int n).

Pasa un local de Main a mark

Declara int room = 4; dentro de Main. Llama mark(room);. Dentro de mark, sigue escribiendo n. La pantalla sigue mostrando 4. El nombre local en Main es room. El nombre del parámetro en mark es n. Son nombres distintos en lugares distintos. El valor 4 es lo que viaja.

Este es el segundo archivo. Enseña la misma visibilidad con un local en Main. Ejecuta dotnet run. Sigues viendo una línea: 4. Si cambias room a 9 y dejas el cuerpo del método solo, la pantalla muestra 9. El método sigue escribiendo el valor que llegó en n. Main también puede escribir room si añades Console.WriteLine(room); en Main — ese nombre pertenece ahí. Main aún no puede escribir n. Después de ver la forma room, vuelve al archivo guardado de una sola llamada si esa es la forma que quieres guardar: mark(4); en Main.
Si mark declara su propio local — por ejemplo int tag = 1; dentro de las llaves — ese tag es invisible para Main. Intentar Console.WriteLine(tag); en Main falla por la misma razón que falla escribir n desde Main. Las llaves de mark son un muro para los nombres declarados dentro.

Lo que protege el muro

Lee la división en palabras sencillas. Los nombres declarados en Main se quedan en Main salvo que pases sus valores en una llamada. Los nombres declarados en mark — parámetros y locales — se quedan en mark. La llamada lleva valores, no los nombres mismos. La sobrecarga de la página anterior es otra habilidad: varios métodos con un nombre de método compartido. El ámbito trata de dónde se permite que aparezca un nombre de variable o parámetro en el código fuente.
Una demo paint sobrante puede quedar en el mismo archivo y confundir la pantalla si Main aún llama paint("ok"). Limpia Main hasta la llamada mark que estás probando. No anides mark dentro de las llaves de Main. Los métodos se sientan dentro de la clase, junto a Main.
Escribir Console.WriteLine("n"); en Main escribe la letra n entre comillas. No escribe el parámetro. Mantén Console.WriteLine(n) dentro de mark cuando quieras el valor que llegó por la llamada. Escribir mark(); con paréntesis vacíos falla cuando el encabezado aún dice mark(int n) — la llamada debe enviar un int, ya sea un literal como 4 o un local como room.

Puedes escribir mark(int n), escribir n dentro de ese método y mantener n fuera de Main. Puedes declarar room en Main y pasar room a mark. La pantalla muestra el valor que cruzó la llamada. Los nombres no se filtran solos por las llaves. La página siguiente es recursion, donde un método se llama a sí mismo con un argumento más pequeño hasta que una condición de parada termina la cadena.

La pantalla guarda el valor que cruzó

El archivo que guardas escribe 4 cuando Main llama mark(4);. El nombre n está en la línea de escritura dentro de mark, y la letra n no está en la pantalla como etiqueta impresa a menos que la hayas puesto entre comillas. Anidar mark dentro de Main no es la forma que construye esta lección.