Entrada

Digite leaf depois que o programa começou, e a tela mostra leaf. Essa palavra não está no arquivo. O arquivo Pine cria um nome, plant, e espera. Você digita leaf e pressiona Enter. Console.WriteLine(plant) escreve leaf. Até agora outra tela significava editar a linha de guarda, porque a palavra ficava no arquivo entre aspas. Mantenha a classe pública chamada Pine. Você não está reinstalando o SDK.

O arquivo espera uma linha digitada

Abra o arquivo Pine. O nome da classe continua Pine. Esta página não renomeia o tipo. Dentro de Main, substitua a antiga linha de guarda que tinha aspas. A nova linha de guarda é string plant = Console.ReadLine();. A palavra-chave string ainda diz que este nome guarda letras. plant ainda começa com um p minúsculo. O sinal = ainda guarda letras nesse nome. O que é novo é o lado direito. Console.ReadLine() não tem aspas. Não há leaf nesta linha. A linha pede ao console uma linha digitada. O programa espera ali até você pressionar Enter. Quando você pressiona Enter, ReadLine guarda as letras que você digitou antes desse Enter. Ele não guarda o Enter em si. Depois a linha termina no ponto e vírgula. Guardar ainda não é escrever. O programa ainda não escreveu a própria linha.

A linha de escrita continua o nome nu, a mesma forma do arquivo que você guardava na página anterior: Console.WriteLine(plant);. Sem aspas. C# lê o nome plant, escreve as letras que esse nome guarda, e termina a linha. Essas letras são o que ReadLine acabou de guardar. Se você digitou leaf, o programa escreve leaf. Se você digitou stem, o programa escreve stem. O arquivo não mudou entre essas duas execuções. Salve o arquivo.

O arquivo que você guarda

Mantenha esta forma de ensino. A palavra que você vai digitar não está no arquivo. Procure no arquivo as letras l, e, a, f. Elas não estão lá. A linha guardada se chama plant. A linha de escrita usa plant e não contém aspas.

Leia o arquivo de cima e decida o que pode chegar à tela. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. Nenhuma dessas palavras é letra para a tela. string plant = Console.ReadLine(); guarda uma linha digitada em plant. Ela não escreve nada por si. Console.WriteLine(plant); é a única linha de escrita. Ela escreve as letras guardadas e termina a linha. O nome plant não é escrito. Console não é escrito. O ponto e vírgula não é escrito.

O que você digita e o que o programa escreve

Execute com dotnet run. Depois desse comando, o programa está esperando em Console.ReadLine(). Ele não terminou, e não escreveu leaf, porque você ainda não deu uma linha. O cursor fica numa linha nova. Digite as letras l, e, a, f. O terminal mostra essas letras enquanto você pressiona as teclas. Esse mostrar é o terminal repetindo suas teclas. Não é Console.WriteLine. Depois pressione Enter.

Enter termina a espera. ReadLine guarda leaf em plant e não guarda o Enter. WriteLine então escreve leaf e termina a linha. Você pode ver leaf, e debaixo dele leaf de novo. O primeiro leaf são as teclas que o terminal mostrou. O segundo leaf é o programa. A linha do programa não tem aspas. São quatro letras, depois a linha termina. O programa termina depois dessa linha de escrita. Se o único leaf que você quer julgar é a linha do programa, julgue a linha que aparece depois que você pressiona Enter.

Se a linha do programa for plant, a linha de escrita tem aspas em volta de plant. O arquivo que você guarda não tem. Se dotnet run escrever leaf de imediato e nunca esperar, o arquivo ainda guarda uma palavra entre aspas, como string plant = "leaf";, e nunca chama ReadLine. Procure aspas em volta de leaf. O arquivo que você guarda não tem nenhuma. Você não reinstala o .NET SDK por uma tela que mostra a palavra errada.

Maiúsculas são copiadas como você digita. Se você digitar Leaf com L maiúsculo e pressionar Enter, a linha do programa é Leaf. O arquivo ainda não contém essas letras. Um Enter vazio também é uma linha real. Pressione Enter sem digitar letras. ReadLine não guarda nenhuma letra em plant. WriteLine escreve uma linha sem letras. O programa rodou. A espera terminou porque o Enter chegou. O arquivo que você guarda é o que você tenta com leaf, quatro letras minúsculas.

Um espaço fica na linha

ReadLine lê até Enter, não até um espaço. Digite leaf, depois um espaço, depois stem, depois Enter. As letras guardadas em plant são leaf, um espaço, e stem. Console.WriteLine(plant) escreve leaf stem. O espaço é um caractere guardado, do mesmo jeito que um espaço entre aspas era guardado quando a palavra vivia no arquivo. Esta página não corta a linha no espaço. O arquivo que você guarda continua o leitor de uma linha. Você só muda o que digita, não o arquivo, quando quer o espaço na tela.

Duas linhas digitadas, dois Enter

Um programa pode pegar uma segunda linha. Debaixo da primeira linha de escrita, guarde uma nova linha no mesmo nome, depois escreva o nome de novo. A nova linha de guarda é plant = Console.ReadLine();. Ela não começa com string. plant já existe, então esta linha só substitui as letras que o nome guarda. A próxima linha de escrita é de novo Console.WriteLine(plant);. O programa agora espera duas vezes. Cada ReadLine espera o próprio Enter.

Este é o segundo arquivo. Não é o arquivo que você guarda. O arquivo que você guarda espera uma vez e escreve uma vez. Use esta segunda forma quando quiser duas linhas digitadas, depois coloque de volta o único ReadLine e o único WriteLine.

Rode dotnet run. O programa espera. Digite leaf e pressione Enter. O terminal mostra leaf, e o programa escreve leaf debaixo. O programa espera de novo. Ele não terminou. Digite stem e pressione Enter. O terminal mostra stem, e o programa escreve stem debaixo. As linhas do programa são leaf, depois stem. As teclas ecoadas ficam acima de cada uma dessas linhas. Se as duas linhas do programa disserem leaf, o segundo ReadLine nunca rodou, ou você digitou leaf nas duas vezes. Se o programa escrever stem antes de você ter digitado uma segunda linha, o segundo WriteLine não está debaixo de um segundo ReadLine. A tela segue a ordem das linhas no arquivo, e cada espera segue o ReadLine que ainda não recebeu Enter.

Não escreva string uma segunda vez para o mesmo nome. string plant = Console.ReadLine();, colocado debaixo de uma linha que já criou plant, é outro erro. Essa linha tenta criar plant de novo. O build escreve um erro e não fica quieto. O reparo é apagar o segundo string e deixar plant = Console.ReadLine();. O nome é criado uma vez. As linhas depois só mudam as letras que ele guarda. No arquivo que você guarda não há segundo ReadLine nenhum.

Aspas em volta do nome escrevem o nome

A linha de escrita no arquivo que você guarda é Console.WriteLine(plant); sem aspas. Se você colocar aspas em volta do nome depois de uma linha digitada de verdade, a linha fica Console.WriteLine("plant");. Essas aspas marcam letras para a tela. As letras entre elas são p, l, a, n, t. C# não procura o nome. Você pode digitar leaf e pressionar Enter, e ReadLine pode guardar leaf em plant, e a linha do programa ainda mostra plant. A palavra digitada não é escrita, porque a linha de escrita nunca usou o nome.

Este é o terceiro arquivo. Não é o arquivo que você guarda. Guarde-o o bastante para ver a única linha do programa plant depois de digitar leaf, depois tire as aspas da linha de escrita.

O nome precisa existir depois de ReadLine

C# lê o arquivo de cima. A linha que preenche plant precisa ficar acima da linha que escreve plant. Se você colocar primeiro Console.WriteLine(plant);, e só depois escrever string plant = Console.ReadLine();, a linha de escrita nomeia plant antes de plant existir. O build escreve um erro. Ele não fica quieto. Não há tela em que confiar enquanto o build escreve um erro. O reparo é mover a linha ReadLine de volta acima da linha de escrita.

Este quarto arquivo é a ordem quebrada. Não é o arquivo que você guarda. Guarde-o só até o build escrever o erro, depois coloque a linha ReadLine de volta no topo.

WriteLine não guarda uma linha digitada

A linha de guarda precisa chamar ReadLine, não WriteLine. Se a linha for string plant = Console.WriteLine();, o build escreve um erro. WriteLine escreve na tela e não devolve letras a um nome. Não é uma guarda que espera. Não há leaf digitado em que confiar enquanto o build escreve um erro. O reparo é colocar Console.ReadLine() de volta à direita de =.

Este quinto arquivo é a chamada de guarda errada. Não é o arquivo que você guarda. Guarde-o só até o build escrever o erro, depois coloque ReadLine de volta.

A tela é a linha que você digitou

Agora você pode preencher um nome pelo teclado e escrever essa linha sem colocar a palavra entre aspas no arquivo. string plant = Console.ReadLine(); espera Enter e guarda as letras digitadas. Console.WriteLine(plant); escreve essas letras e termina a linha. Um segundo ReadLine espera de novo. Aspas em volta do nome escrevem as letras do nome. A linha ReadLine precisa ficar acima da primeira linha que usa o nome. WriteLine no lado da guarda não é guarda. A próxima página começa Value Types, para que um nome possa guardar um número com um tipo diferente de string, enquanto esta página fica numa linha digitada de letras.