Parâmetros

Escreva um método chamado greet que recebe uma palavra. Dentro dos parênteses escreva string name. No corpo escreva hi, um espaço e depois name com Console.WriteLine("hi " + name);. Desde Main chame greet("lena");. A tela deve mostrar uma linha: hi lena. As letras lena não estão fixas dentro do método. Elas chegam pela chamada e sentam no nome name para essa passagem. Essa entrega é o que esta página ensina. Mantenha a classe pública com o nome Pine.

Um nome dentro dos parênteses

Na página de métodos, os parênteses depois de ring ficavam vazios. A linha de escrita era sempre ding. Aqui os parênteses guardam um nome tipado para que cada chamada possa enviar um valor diferente. Esse nome tipado é um parâmetro. O valor que você escreve na chamada é o argumento dessa passagem.
Abra o arquivo Pine. O nome da classe continua Pine. Esta página não renomeia o tipo. Apague qualquer demo ring(); com parênteses vazios se for tudo o que Main ainda guarda e você estiver pronto para a forma desta página. Apague qualquer resto de foreach. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação.
Fora de Main, ainda dentro das chaves da classe, o cabeçalho começa com static void nesta forma iniciante. Entre os parênteses ficam string e depois name — o tipo primeiro, depois o nome do parâmetro. C# escreve o tipo string com s minúsculo nesta forma. O corpo usa name sem aspas em volta, ligado ao texto fixo "hi " com um mais. Aspas em volta de "hi " marcam as letras fixas. O name nu marca o valor que chegou da chamada. Salve o arquivo antes de executar. O primeiro programa completo está na caixa seguinte.

O arquivo que você guarda

Esta é a versão que você executa primeiro. Main guarda a chamada com um valor dentro dos parênteses. greet guarda a linha de escrita que usa esse valor.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. A chamada greet("lena"); envia o texto para o parâmetro. static void greet(string name) guarda Console.WriteLine("hi " + name);. Uma linha na tela: hi lena.

Execute com dotnet run. O programa escreve uma linha e para. Não espera você digitar. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha greet("lena"); mais o método greet acima. A tela mostra hi lena. Se a tela mostrar só ding, uma chamada antiga ring(); ainda está a correr. Se a tela mostrar as letras name, uma linha de escrita tem aspas em volta dessa palavra: Console.WriteLine("name");. Você não reinstala o SDK .NET por uma tela que mostra a linha errada.

Percorra uma execução completa em ordem. C# começa em Main. A chamada greet("lena"); envia o texto lena para o parâmetro name. Dentro de greet, WriteLine monta hi, um espaço e depois esse valor, por isso a tela mostra hi lena. Depois greet termina e Main termina. Você não escreveu Console.WriteLine("hi lena"); dentro de Main. Escreveu a parte fixa uma vez sob greet e passou lena pela chamada.
O parâmetro fica vazio até a chamada o preencher. Na primeira chamada, name guarda lena só para essa passagem. Numa chamada posterior com "sam", o mesmo nome de parâmetro guarda um valor diferente. Você não cria um segundo método para a segunda palavra; envia um novo argumento para o mesmo cabeçalho.

Mesmo método, palavras diferentes

Mude só Main para chamar greet duas vezes com dois argumentos diferentes. Deixe o método greet em paz.

Este é o segundo arquivo. Ensina o mesmo método com duas chamadas. Execute dotnet run. A tela deve mostrar duas linhas: hi lena, depois hi sam. A primeira chamada preenche name com lena. A segunda chamada preenche name com sam. Você não copiou o WriteLine sob greet. Mudou só os valores dentro das chamadas.
Se chamar greet() com parênteses vazios enquanto o cabeçalho ainda diz string name, a compilação escreve um erro — a chamada deve fornecer um string. Se deixar um ring(); antigo com parênteses vazios da página de métodos no mesmo Main, essa chamada não combina com greet, e um método ring restante pode ainda escrever ding ao lado das suas linhas hi. Limpe Main para as chamadas greet que esta lição precisa. Depois de ver duas linhas, volte ao arquivo de uma chamada se for a forma que quer guardar: um greet("lena"); em Main.

Um número inteiro como valor

Parâmetros não são só para texto. Escreva um segundo método que recebe um int chamado n e o escreve. Chame-o desde Main com números inteiros como show(9); e show(4);.

Este é o terceiro arquivo. Não é o arquivo que você guarda para a forma greet. Execute dotnet run. A tela deve mostrar duas linhas: 9, depois 4. Nenhuma aspas envolve 9 ou 4 na chamada — são valores int, não texto. Dentro de show, Console.WriteLine(n) escreve o número que chegou. Depois de ver essas duas linhas, volte à demo greet. As duas versões são C# válido. Ensinam a mesma ideia: a chamada envia um valor, o parâmetro o guarda para o corpo.
Leia a execução int mais uma vez. A primeira chamada põe n em 9 e escreve 9. A segunda chamada põe n em 4 e escreve 4. O nome n é declarado uma vez no cabeçalho como int n. Cada chamada dá um valor novo para essa passagem. Passar uma palavra entre aspas para show, como show("nine");, não combina com int nesta forma — a compilação escreve um erro. Passar um número nu para greet, como greet(3);, não combina com string — a compilação escreve erro de novo. Combine o tipo do argumento com o tipo do parâmetro.

Uma confusão comum é escrever o nome do parâmetro como texto: Console.WriteLine("name");. Isso escreve as letras n-a-m-e. Não escreve lena. Mantenha Console.WriteLine("hi " + name) sem aspas em volta de name quando quiser as letras do argumento na tela. Outra confusão é declarar o parâmetro em Main em vez do cabeçalho do método. O nome tipado fica dentro de greet(...) ou show(...), não nos parênteses de Main nesta página. () vazios da página ring não bastam quando o cabeçalho pede string name.

void ainda significa que nada volta pela chamada. Você pode pôr string name ou int n nos parênteses de um método, passar um valor correspondente na chamada e escrever esse valor a partir do corpo. Duas chamadas com dois argumentos escrevem duas linhas diferentes sem copiar o método. A página seguinte é return, onde um método devolve um valor a Main em vez de só escrever dentro do corpo.

A tela guarda o argumento

O arquivo que você guarda escreve hi lena quando Main chama greet("lena");. O nome name está na linha de escrita sem aspas em volta. Aspas em volta de name escrevem letras, não o argumento. () vazios na chamada não combinam com um cabeçalho que pede string name.