Parámetros

Escribe un método llamado greet que tome una palabra dentro. Dentro de los paréntesis escribe string name. En el cuerpo escribe hi, un espacio y luego name con Console.WriteLine("hi " + name);. Desde Main llama greet("lena");. La pantalla debería mostrar una línea: hi lena. Las letras lena no están fijas dentro del método. Llegan por la llamada y se sientan en el nombre name para ese paso. Esa entrega es lo que enseña esta página. Mantén el nombre de la clase pública Pine.

Un nombre dentro de los paréntesis

En la página de métodos los paréntesis después de ring quedaron vacíos. La línea de escritura siempre era ding. Aquí los paréntesis guardan un nombre tipado para que cada llamada pueda enviar un valor distinto. Ese nombre tipado es un parámetro. El valor que escribes en la llamada es el argumento de ese paso.
Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Borra cualquier demo ring(); con paréntesis vacíos si eso es todo lo que Main aún guarda y ya estás listo para la forma de esta página. Borra cualquier resto de foreach. Borra cualquier línea ReadLine. El archivo que guardas no espera escritura.
Fuera de Main, aún dentro de las llaves de la clase, el encabezado en esta forma para principiantes empieza con static void. Entre los paréntesis se sientan string y luego name — primero el tipo, luego el nombre del parámetro. C# escribe el tipo string con s minúscula en esta forma. El cuerpo usa name sin comillas alrededor, unido al texto fijo "hi " con un más. Las comillas alrededor de "hi " marcan las letras fijas. El name desnudo marca el valor que llegó de la llamada. 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 con un valor dentro de los paréntesis. greet guarda la línea de escritura que usa ese valor.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde empieza el tiempo de ejecución. La llamada greet("lena"); envía el texto al parámetro. static void greet(string name) guarda Console.WriteLine("hi " + name);. Una línea en la pantalla: hi lena.

Ejecútalo con dotnet run. El programa escribe una línea y se detiene. No espera a que tú escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y guarda greet("lena"); más el método greet de arriba. La pantalla muestra hi lena. Si la pantalla muestra solo ding, una llamada antigua ring(); sigue corriendo. Si la pantalla muestra las letras name, una línea de escritura tiene comillas alrededor de esa palabra: Console.WriteLine("name");. No reinstales 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 greet("lena"); envía el texto lena al parámetro name. Dentro de greet, WriteLine arma hi, un espacio y luego ese valor, así que la pantalla muestra hi lena. Luego termina greet y termina Main. No escribiste Console.WriteLine("hi lena"); dentro de Main. Escribiste la parte fija una vez bajo greet y pasaste lena desde la llamada.
El parámetro está vacío hasta que la llamada lo llena. En la primera llamada, name guarda lena solo para ese paso. En una llamada posterior con "sam", el mismo nombre de parámetro guarda un valor distinto. No creas un segundo método para la segunda palabra; envías un argumento nuevo al mismo encabezado.

El mismo método, palabras distintas

Cambia solo Main para que llame greet dos veces con dos argumentos distintos. Deja el método greet en paz.

Este es el segundo archivo. Enseña el mismo método con dos llamadas. Ejecuta dotnet run. La pantalla debería mostrar dos líneas: hi lena, luego hi sam. La primera llamada llena name con lena. La segunda llamada llena name con sam. No copiaste WriteLine bajo greet. Solo cambiaste los valores dentro de las llamadas.
Si llamas greet() con paréntesis vacíos mientras el encabezado aún dice string name, la compilación escribe un error — la llamada debe aportar un string. Si dejas un ring(); antiguo con paréntesis vacíos de la página de métodos en el mismo Main, esa llamada no coincide con greet, y un método ring sobrante puede seguir escribiendo ding junto a tus líneas hi. Limpia Main a las llamadas greet que esta lección necesita. Después de ver dos líneas, vuelve a poner el archivo de una sola llamada que guardas si esa es la forma que quieres conservar: un greet("lena"); en Main.

Un número entero como valor

Los parámetros no son solo para texto. Escribe un segundo método que tome un int llamado n y lo escriba. Llámalo desde Main con números enteros como show(9); y show(4);.

Este es el tercer archivo. No es el archivo que guardas para la forma greet. Ejecuta dotnet run. La pantalla debería mostrar dos líneas: 9, luego 4. Sin comillas alrededor de 9 o 4 en la llamada — son valores int, no texto. Dentro de show, Console.WriteLine(n) escribe el número que llegó. Después de ver esas dos líneas, vuelve a poner el demo de greet. Ambas versiones son C# válido. Enseñan la misma idea: la llamada envía un valor, el parámetro lo guarda para el cuerpo.
Lee la ejecución de int una vez más. La primera llamada pone n en 9 y escribe 9. La segunda llamada pone n en 4 y escribe 4. El nombre n se declara una vez en el encabezado como int n. Cada llamada le da un valor nuevo para ese paso. Pasar una palabra entre comillas a show, como show("nine");, no coincide con int en esta forma — la compilación escribe un error. Pasar un número desnudo a greet, como greet(3);, no coincide con string — la compilación escribe un error otra vez. Haz coincidir el tipo del argumento con el tipo del parámetro.

Una confusión común es escribir el nombre del parámetro como texto: Console.WriteLine("name");. Eso escribe las letras n-a-m-e. No escribe lena. Mantén Console.WriteLine("hi " + name) sin comillas alrededor de name cuando quieras las letras del argumento en la pantalla. Otra confusión es declarar el parámetro en Main en lugar del encabezado del método. El nombre tipado pertenece dentro de greet(...) o show(...), no dentro de los paréntesis de Main en esta página. Los () vacíos de la página ring no bastan cuando el encabezado pide string name.

void sigue significando que nada vuelve por la llamada. Puedes poner string name o int n dentro de los paréntesis de un método, pasar un valor coincidente en la llamada y escribir ese valor desde el cuerpo. Dos llamadas con dos argumentos escriben dos líneas distintas sin copiar el método. La página siguiente es return, donde un método devuelve un valor a Main en lugar de solo escribir dentro del cuerpo.

La pantalla guarda el argumento

El archivo que guardas escribe hi lena cuando Main llama greet("lena");. El nombre name está en la línea de escritura sin comillas alrededor. Las comillas alrededor de name escriben letras, no el argumento. Los () vacíos en la llamada no coinciden con un encabezado que pide string name.