Comentários

Uma nota no programa Pine é para a pessoa que lê o arquivo. A tela continua pine. Console.WriteLine("pine"); ainda é a linha que escreve essa palavra. Esta página coloca a nota em duas formas, mostra que pine ainda é a única linha, e depois mostra o único lugar que remove pine. Você não está instalando o SDK de novo. Você não está relendo qual linha é Main. Mantenha a classe pública chamada Pine e mantenha o comando de escrita ativo no arquivo que você guarda.

Uma nota não é um comando

Um comando é uma linha que o C# executa. Console.WriteLine("pine"); é um comando. Ele escreve pine e termina a linha. Uma nota é um texto que você deixa no arquivo para que você, ou o próximo leitor, lembre de algo. O compilador e o runtime pulam uma nota. Pular significa que a nota não é executada, e também não é escrita na tela. As letras da nota ficam no arquivo depois da execução. Você pode abrir o arquivo e lê-las. Você não as encontra na tela. A tela ainda tem uma linha, e essa linha é pine, desde que o próprio comando de escrita não seja a nota.

Há duas formas. Uma nota de linha começa com duas barras, //. O C# pula dessas duas barras até o fim dessa mesma linha. A próxima linha é de novo uma linha normal. Uma nota de bloco começa com /* e termina no primeiro */. O C# pula tudo entre essas duas marcas, inclusive as quebras de linha. Uma nota de bloco pode caber em uma linha ou em várias. As duas formas são notas. Nenhuma escreve a tela. As barras não são impressas. As estrelas não são impressas. As palavras que você põe entre elas não são impressas.

O arquivo que você guarda

Guarde esta forma de ensino. Ela tem uma nota de linha acima do comando de escrita, outra nota de linha na própria linha do comando, e uma nota de linha perto de Main. O comando de escrita ainda está lá, e não está atrás de uma barra.

Leia de cima e decida, para cada linha, se a tela a recebe. A linha using System; prepara nomes curtos e não escreve a tela. A linha da classe ainda é public class Pine. Essa linha nomeia o tipo e não escreve a tela. A linha seguinte é // the teaching type is Pine. As duas barras começam uma nota, então essas palavras são para você. A tela não as mostra. Também não mostra as barras. A linha public static void Main() é onde o runtime começa, e nenhuma dessas palavras está na tela. Isso não mudou desde First Program.

Dentro de Main, a linha // a note for the reader é só uma nota. O runtime chega nela, pula, e vai para a próxima linha. A próxima linha é a que importa: Console.WriteLine("pine"); // the screen is this word. Leia essa linha como duas partes separadas pelas barras. Antes das barras, o comando é Console.WriteLine("pine");. Esse comando escreve pine e termina a linha. Depois das barras, as palavras the screen is this word são uma nota. Elas ficam na mesma linha do comando, e ainda assim são puladas. Uma nota não precisa ocupar uma linha sozinha. Se // aparecer depois de um comando terminado, o comando roda e o resto da linha não. O ponto e vírgula é o que termina o comando. As barras depois do ponto e vírgula começam a nota. Deixe esse ponto e vírgula onde está. A tela mostra pine. Não mostra the screen is this word. Não mostra uma segunda linha.

Rode do mesmo jeito que depois da instalação. Na pasta do projeto, digite dotnet run. A tela mostra pine. Uma linha. Sem aspas. Sem barras. Sem segunda linha. A palavra pine ainda é a palavra entre as aspas. Não é uma palavra que você digitou no comando, e não é uma palavra que você digitou numa nota. As notas não fazem a build falhar, e não se imprimem sozinhas.

Uma nota de bloco

Uma nota de bloco é a outra forma. Você a usa quando a nota é mais longa que uma linha, ou quando quer que o fim da nota seja uma marca que você escolhe, não o fim da linha. A marca de abertura é /*. A marca de fechamento é */. O C# pula da abertura até o fechamento, e o primeiro */ é o fim. Um */ posterior não faz parte desta nota, porque a nota já terminou. Esta página usa uma nota de bloco, então você verá uma abertura e um fechamento.

Troque as notas de linha dentro de Main por uma nota de bloco, e deixe o comando de escrita no lugar. A tela não muda. Este é o segundo arquivo. Você está olhando como a nota parece. O arquivo que você guardava usava notas de linha. Este usa uma nota de bloco. Os dois escrevem pine.

A nota de bloco começa na linha que começa com /*. As palavras a note estão dentro. A linha seguinte, across two lines, também está dentro, porque o */ de fechamento ainda não apareceu. O */ no fim dessa segunda linha termina a nota. O C# então roda Console.WriteLine("pine"); porque esse comando está fora da nota, abaixo da marca de fechamento. A tela mostra pine. As palavras a note e across two lines não estão na tela. As estrelas e as barras não estão na tela. Se você subir o */ para que fique na primeira linha, logo depois de a note, então a segunda linha deixa de estar dentro da nota. Essa segunda linha teria de ser uma linha C# de verdade, e across two lines não é um comando. A build escreveria um erro em vez de ficar quieta. Nesta página o */ fica no fim da segunda linha, então a nota inteira é pulada e a build fica quieta.

Não tente colocar uma nota de bloco dentro de outra. O primeiro */ termina a nota, mesmo que você quisesse que esse */ terminasse uma nota interna. Depois dessa primeira marca de fechamento, o C# lê comandos de novo. Esta página não aninha notas. Uma abertura, um fechamento, depois o comando de escrita.

O erro que remove pine

A nota e o comando de escrita são linhas diferentes, ou partes diferentes de uma linha, nos arquivos acima. O erro é colocar as duas barras na frente do comando de escrita, de modo que o comando se torne a nota. Guarde esta terceira forma só o tempo suficiente para ver a tela vazia, depois coloque o comando de escrita de volta. Este não é o arquivo que você guarda.

dotnet run então não escreve nada útil na tela para esta checagem de ensino. Não há pine. Não há palavra entre aspas vazia. Não há segunda linha. A tela está em branco porque o comando que escrevia pine está atrás de //. As letras Console.WriteLine("pine") ainda estão no arquivo, e você pode lê-las, mas agora são uma nota. As aspas não as salvam. Aspas marcam uma palavra dentro de um comando. Elas não transformam uma nota de volta em comando. As duas barras na frente decidem, e decidem que o resto da linha é para o leitor.

Volte o arquivo para o que você guarda. A linha de escrita deve ser Console.WriteLine("pine"); com a nota, se quiser uma, depois do ponto e vírgula. Então dotnet run escreve pine de novo. Se a tela estiver em branco, procure // antes de Console. Essa é a checagem inteira. Você não reinstala o SDK .NET por uma tela em branco causada por uma nota. Mantenha hábitos Java restantes com System.out.println fora desta página quando praticar a linha de escrita C#. Mantenha inventar rotas ASP.NET fora desta página.

A tela ainda é pine

Agora você pode colocar uma nota no arquivo Pine sem mudar a tela. Uma nota de linha começa com //. Uma nota de bloco começa com /* e termina no primeiro */. A tela do arquivo que você guarda é pine, escrita por Console.WriteLine("pine");. Se // ficar na frente desse comando, a tela não tem linha. Uma nota pode conter quaisquer palavras, incluindo Pine, Main, e pine. Essas palavras ainda não estão na tela. A página seguinte muda como as linhas de saída são escritas, para que a tela possa mostrar mais de um hábito curto. As notas desta página continuam notas.