Classes

Uma classe é um tipo nomeado que você declara com class. Coloque public class Badge no mesmo arquivo de ensino que Pine, ou mantenha-o ao lado de Pine como segundo tipo. Dentro de Badge, escreva um método static curto show que escreve ready. Em Pine, mantenha Main e chame Badge.show();. Execute com dotnet run. A tela deve mostrar uma linha: ready. Aqui você não conta regressivamente com recursão. Você nomeia um segundo tipo e pede ao método desse tipo que escreva. Esse segundo tipo nomeado — uma classe que não é só a classe que inicia — é o que esta página ensina. Mantenha a classe pública inicial chamada Pine.

O tipo fica ao lado do iniciador

Até as páginas de métodos, quase toda demo mantinha Main e os métodos auxiliares dentro de uma só classe pública chamada Pine. Isso ainda funciona. Esta página adiciona de propósito uma segunda classe. Badge é um nome de tipo. Não precisa ser o programa que inicia. Pine é o programa que inicia. Nesta forma iniciante os dois tipos podem viver num só arquivo para dotnet run continuar simples. O que importa é o nome do tipo: Badge possui show, e Pine pede por ele.
Abra o arquivo Pine. O nome da classe inicial permanece Pine. Esta página não renomeia o iniciador. Apague qualquer resto de recursão down se essa forma ainda for tudo o que você tem em Main. Apague qualquer resto mark. Apague qualquer linha ReadLine. O arquivo que você guarda não espera digitação.
Fora das chaves de Pine — ainda no mesmo arquivo — escreva public class Badge. Dentro de Badge, escreva static void show(). O corpo é uma linha de escrita: Console.WriteLine("ready");. Mantenha void nesta página. O método não devolve um número. Só escreve uma palavra. Não há Main em Badge nesta página. É de propósito. Uma classe pode guardar métodos sem ser a classe inicial.
Salve o arquivo antes de executar. O primeiro programa em caixa mostra Badge sozinho para você ler o tipo com clareza. O segundo programa em caixa é a forma completa guardada com Pine e Badge juntos.

Pine inicia; Badge faz a escrita

Pine mantém public static void Main(). Dentro de Main, escreva uma chamada: Badge.show();. Essa chamada nomeia o tipo Badge, um ponto, depois o método show. Você não escreve show(); sozinho dentro de Pine a menos que show também viva em Pine. Nesta página show pertence a Badge, então a chamada leva o nome do tipo.

Leia o arquivo guardado de cima. using System; prepara nomes curtos. public class Pine é o iniciador. public static void Main() é onde o runtime começa. A chamada Badge.show() entra no método do tipo Badge. Esse método escreve ready e retorna. Depois Pine termina. A palavra na tela veio de Badge, não de um WriteLine escrito dentro do próprio Pine. Essa separação é o ponto: uma classe inicia o programa; outra classe possui o auxiliar.

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 Badge.show(); em Pine mais o método show em Badge. A tela mostra ready. Se a tela mostrar 3, depois 2, depois 1, uma chamada down(3) restante ainda está rodando. Se a tela mostrar as letras Badge, uma linha de escrita tem aspas: Console.WriteLine("Badge");. Você não reinstala o SDK .NET por uma tela que mostra a linha errada.
Percorra a execução mais uma vez em ordem. C# começa em Pine.Main. A única instrução ali é Badge.show();. Essa chamada salta para o método show de Badge. Dentro de show, WriteLine escreve ready. Depois show termina, e Main não tem mais nada, então o programa encerra. Você não colocou Console.WriteLine("ready"); dentro de Pine nesta página. Colocou sob Badge e pediu pelo nome do tipo.

Tipo ao lado do papel

Leia o pareamento uma vez numa tabela pequena. Cada classe tem um trabalho nesta página.

Uma confusão comum é escrever show(); dentro de Pine sem o prefixo Badge. quando show só existe em Badge. A compilação então procura show dentro de Pine e não encontra. Outra confusão é colocar Main só em Badge e tirar de Pine enquanto você ainda espera a forma antiga de iniciador — mantenha Main em Pine para o arquivo guardado desta lição. Demos de recursão restantes podem confundir Main. Limpe Main até Badge.show(); enquanto aprende a forma de dois tipos. Você não precisa de down aqui.
Escrever Console.WriteLine("Badge"); dentro de Pine escreve a palavra Badge. Não chama o método no tipo. Mantenha Badge.show(); quando quiser a linha de escrita que vive em Badge.

O que esta página ainda não faz

Esta página não escreve new Badge(). Criar um objeto a partir de uma classe é a página seguinte. Aqui a chamada é Badge.show() — um método static no próprio nome do tipo. Você também ainda não guarda campos num badge. Campos ficam para uma página posterior neste módulo. O trabalho agora é só o tipo nomeado ao lado do iniciador, e uma chamada que usa esse nome de tipo.
Você pode mudar a palavra escrita dentro de show para set e executar de novo. A tela deve seguir a string que você colocou em Badge. Pine mantém a mesma chamada. É outra forma de ver a separação: edite o método do tipo, mantenha a chamada do iniciador.
Não aninhe Badge dentro das chaves de Pine. Nesta página as duas classes ficam como irmãs no arquivo. Métodos de Badge ficam dentro de Badge. Main fica dentro de Pine.

Você pode declarar public class Badge, colocar static void show() dentro dela e chamar Badge.show(); a partir de Pine.Main. Execute com dotnet run. A tela mostra a linha escrita por show. Uma classe é esse tipo nomeado. Pense em Badge como uma prateleira etiquetada para auxiliares que não precisam iniciar o programa. Pine continua a porta que você abre com dotnet run. A próxima página é objects, onde você constrói um valor a partir de uma classe com new.

A tela guarda a linha de escrita de Badge

O arquivo que você guarda escreve ready quando Main chama Badge.show();. O nome Badge está na chamada, e as letras Badge não aparecem na tela como rótulo impresso a menos que você as tenha colocado entre aspas. Aninhar Badge dentro de Pine não é a forma que esta lição constrói.