Métodos

Escreva um método chamado ring que escreve uma palavra: ding. Coloque essas linhas de escrita sob static void ring() com parênteses vazios. Dentro de Main, escreva só ring(); — o nome, depois parênteses vazios, depois um ponto e vírgula. Execute o programa. A tela deve mostrar uma linha: ding. Main não guarda o WriteLine de ding. O método guarda. Essa divisão é o que esta página ensina. Mantenha a classe pública com o nome Pine.

Linhas que vivem sob ring

Até agora, a maior parte do seu trabalho de escrita ficava diretamente dentro de Main. Isso ainda funciona. Um método dá às mesmas linhas um nome próprio. Você escreve as linhas uma vez sob esse nome. Depois Main as pede escrevendo o nome como uma chamada.
Abra o arquivo Pine. O nome da classe continua Pine. Esta página não renomeia o tipo. Apague qualquer foreach que percorra plants ou slots se essa forma ainda estiver lá. Apague um for contado com break ou continue se ainda estiver lá. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação e não tem demo de laço restante em Main.
Fora de Main, ainda dentro das chaves da classe, você escreverá static void ring() com um corpo que executa Console.WriteLine("ding");. O programa completo está na caixa seguinte para copiar limpo.
A palavra static fica nesta forma iniciante para que Main possa chamar ring sem criar um objeto. A palavra void significa que este método não devolve um valor ao chamador — só executa o seu corpo. O nome ring é o rótulo que você digitará em Main. Os parênteses vazios () significam que o método desta página não recebe valores. As chaves guardam o corpo. Salve o arquivo antes de executar.

O arquivo que você guarda

Aqui está o pequeno programa completo desta página. Main guarda só a chamada. ring guarda a linha de escrita. Não há contador de índice nem passeio de array neste arquivo guardado.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde a execução começa. A única instrução em Main é ring();. Abaixo de Main, ainda dentro da classe, static void ring() guarda Console.WriteLine("ding");. Uma linha na tela: ding.

Execute com dotnet run. O programa escreve uma linha e para. Não espera que você digite. Se dotnet run esperar, ReadLine ainda está no arquivo. Apague essa linha e mantenha ring(); em Main mais o método ring acima. A tela mostra ding. Se a tela mostrar leaf e mint, um foreach restante ainda escreve. Se a tela mostrar as letras ring, uma linha de escrita tem aspas em volta dessa palavra: Console.WriteLine("ring");. Você não reinstala o SDK .NET por uma tela que mostra a linha errada.

Percorra uma execução completa na ordem. C# começa em Main. A única instrução em Main é ring();. Essa chamada salta para o método ring. Dentro de ring, WriteLine escreve ding. Depois ring termina, e não resta nada em Main, então o programa acaba. Você não pôs Console.WriteLine("ding"); dentro de Main nesta página. Pôs sob ring e pediu pelo nome. Se a tela mostrar ding, a chamada chegou ao corpo. Se a tela ficar em branco depois de um build limpo, Main nunca chamou ring.
Pense em ring como uma prateleira rotulada para as linhas de escrita. Main não precisa repetir essas linhas. Só precisa do nome da prateleira escrito como uma chamada. Por isso um Main curto ainda pode produzir uma linha de tela clara: o trabalho vive sob o nome do método, e a chamada é o pedido. Quando esse padrão estiver claro, acrescentar outra chamada é só outro pedido à mesma prateleira de linhas de escrita.

Chamar ring desde Main mais de uma vez

Altere só Main para que chame o mesmo método duas vezes. Deixe o método ring em paz. O corpo ainda escreve ding uma vez por chamada.

Este é o segundo arquivo. Não é o arquivo que você guarda para a forma de uma chamada, mas ensina o mesmo método. Execute dotnet run. A tela deve mostrar duas linhas, cada uma dizendo ding. A primeira chamada executa o corpo uma vez. A segunda chamada executa o mesmo corpo de novo. Essa reutilização é a razão de nomear as linhas. Você não copiou o WriteLine uma segunda vez sob ring. Escreveu uma segunda chamada em Main.
Se deixar só um ring();, a tela volta a um único ding. A definição do método não escreve sozinha. Só uma chamada desde Main executa o corpo. Um arquivo que define ring mas nunca o chama pode fazer build e ainda assim mostrar uma tela em branco quando você executa. Depois de ver duas linhas, recoloque o arquivo guardado de uma chamada se essa for a forma que quer salvar: um ring(); em Main.

Peças de um cabeçalho de método

Nesta página o cabeçalho é static void ring(). Leia da esquerda para a direita. static deixa Main chamar o método nesta forma iniciante. void significa que nenhum valor volta pela chamada. ring é o nome. () ficam vazios de propósito: esta sessão não passa palavras nem números para o método. A próxima página, parameters, coloca nomes dentro desses parênteses. A página seguinte, return, muda void quando você precisa de um valor de volta. Guarde as duas para depois. Hoje os () vazios e void bastam.

A chamada em Main deve combinar com o nome exatamente: ring(); com r minúsculo, parênteses vazios e ponto e vírgula. Escrever Ring(); com R maiúsculo é um nome diferente para C#. Escrever ring sem () não é uma chamada nesta forma. Escrever Console.WriteLine("ring"); escreve as quatro letras da palavra ring; não executa o corpo do método. Mantenha a chamada como ring(); quando quiser ding na tela.

Um resto comum é um antigo passeio foreach de plants ainda sentado em Main ao lado da nova chamada. Então a tela pode mostrar leaf e mint, ou 2, 4, e 6, em vez de ding — ou os dois tipos de linhas misturados. Limpe Main até as chamadas ring(); que esta lição precisa. Outra confusão é pôr o método dentro das chaves de Main. Os métodos desta página ficam dentro da classe, ao lado de Main, não aninhados dentro de Main.

foreach da página anterior percorria valores já guardados num array. Esta página não percorre um array. Nomeia um método void e o chama. Não deixe foreach (string plant in plants) no mesmo Main e não se pergunte por que a tela mostra leaf em vez de ding. O Main guardado desta sessão deve guardar só a chamada ring();. O corpo do método guarda a linha de escrita de ding.

Agora você pode escrever static void ring(), pôr um WriteLine nas suas chaves e chamar ring() desde Main para a tela mostrar ding. Chamar duas vezes escreve ding duas vezes sem copiar o corpo. Parênteses vazios e void ficam nesta página de propósito. A próxima página é parameters, onde nomes entram nos parênteses para o método usar valores que você passa desde Main.

A tela é o corpo do método

O arquivo que você guarda escreve ding uma vez quando Main tem uma chamada. O nome ring está na chamada, e as letras ring não aparecem na tela como palavra impressa a menos que as tenha posto entre aspas. () vazios ficam no cabeçalho e na chamada. Aninhar ring dentro de Main não é a forma que esta lição constrói.