Cadeias

string plant = "leaf"; guarda as quatro letras leaf, e Console.WriteLine(plant) escreve leaf. As aspas ficam no arquivo. Elas não estão na tela. A página anterior guardava o número inteiro 4 sem aspas em volta. Aqui o par de aspas é o que segura as letras, e um par faltando faz o build escrever um erro. Mantenha a classe pública chamada Pine. Você não reinstala o SDK.

As aspas seguram as letras

Abra o arquivo Pine. O nome da classe permanece Pine. Esta página não renomeia o tipo. A última página mantinha int count = 4; sem aspas e sem teclado. Esta página não mantém esse número. Apague a linha int se ainda estiver lá. Apague qualquer linha ReadLine. O arquivo que você guarda não tem espera nem linha de número inteiro. As letras só são escritas pela linha de escrita que usa o nome.

Dentro de Main, a linha de guarda é string plant = "leaf";. string é a palavra de tipo. Diz que este nome guarda letras. plant é o nome, e começa com um p pequeno. O sinal = guarda as letras. Em seguida vem o par. A primeira aspa abre as letras. As quatro letras são l, e, a, f, nessa ordem, todas pequenas. A segunda aspa fecha as letras. Nada mais fica entre essas duas aspas: sem espaço, sem letra a mais, sem segunda palavra. O ponto e vírgula termina a linha. Esta linha não escreve a tela. Guardar não é escrever. A tela fica em branco durante esta linha. As aspas fazem parte da linha de guarda. Elas não fazem parte do valor que o nome guarda depois que a linha guardou.

A linha de escrita é o nome nu: Console.WriteLine(plant);. Sem aspas. C# lê o nome plant, escreve as letras que esse nome guarda e termina a linha. Para o arquivo que você guarda, essas letras são l, e, a, f. As marcas de aspas não estão na tela. As letras do nome, p, l, a, n, t, não estão na tela. string não está na tela. Console não está na tela. O ponto e vírgula não está na tela. Salve o arquivo.

O arquivo que você guarda

Mantenha esta forma de ensino. Uma palavra de tipo, string. Um nome, plant. Um par de aspas. Quatro letras entre elas, leaf. Uma linha de escrita, e essa linha usa o nome nu.

Leia de cima. using System; prepara nomes curtos. public class Pine nomeia o tipo. public static void Main() é onde o runtime começa. Nenhuma dessas palavras são as letras na tela. A linha de guarda é string plant = "leaf";. Essa linha guarda as letras. Não escreve nada. Console.WriteLine(plant); é a única linha de escrita. Ela escreve leaf e termina a linha. Uma linha. Sem marcas de aspas nessa linha de tela.

Execute com dotnet run. O programa escreve leaf. Não espera você digitar. As letras já estavam no arquivo. Se dotnet run espera, o arquivo ainda tem ReadLine. Apague essa linha e mantenha string plant = "leaf";. A tela mostra leaf, uma linha, quatro letras, sem marcas de aspas. Se a tela mostra plant, a linha de escrita tem aspas em volta do nome: Console.WriteLine("plant");. Essas aspas marcam as letras p, l, a, n, t. C# não procura o nome, então o leaf guardado não é escrito. O arquivo que você guarda tem o nome nu na linha de escrita, e as aspas em volta de leaf na linha de guarda. Se a tela mostra 4, o arquivo ainda tem o número inteiro da página anterior. O arquivo que você guarda tem leaf, não 4. Você não reinstala o .NET SDK por uma tela que mostra a linha errada.

Uma letra maiúscula entre as aspas é guardada como essa maiúscula. string plant = "Leaf"; faria a linha de escrita escrever Leaf, com um L grande. O arquivo que você guarda não usa isso. Usa quatro letras pequenas. Julgue a tela pelas letras que realmente estão entre as aspas, não por uma palavra que você só pretendeu escrever.

Um espaço é uma das letras

A linha de escrita pode ficar no lugar enquanto as letras entre as aspas mudam. Debaixo da primeira linha de escrita, guarde um novo conjunto de letras no mesmo nome, depois escreva o nome de novo. A nova linha de guarda é plant = "leaf stem";. Não começa com string. plant já existe, então esta linha só substitui as letras que o nome guarda. Entre as aspas desta vez há nove caracteres: l, e, a, f, um espaço, s, t, e, m. O espaço é um deles. Não é uma quebra em duas linhas de guarda, e não é apagado quando a tela é escrita. A próxima linha de escrita é de novo Console.WriteLine(plant);. A tela agora tem duas linhas. A primeira é leaf, das letras que o nome guardava naquele momento. A segunda é leaf stem, das letras que o nome guarda depois de plant = "leaf stem";. Um espaço fica entre leaf e stem nessa segunda linha. As duas palavras não estão em duas linhas separadas.

Este é o segundo arquivo. Não é o arquivo que você guarda. O arquivo que você guarda tem uma linha de guarda, as letras leaf, e sem espaço. Use esta segunda forma quando quiser ver o espaço, depois coloque de volta a única linha de guarda e a única linha de escrita.

Rode dotnet run. A tela mostra leaf, e a linha seguinte é leaf stem. Duas linhas. Sem marcas de aspas. O nome plant não está em nenhuma. Se a segunda linha for leafstem, sem vão, falta o espaço entre as aspas. Se as duas linhas forem leaf, a segunda linha de guarda falta ou ainda diz "leaf". A tela segue a ordem das linhas no arquivo, e segue as letras entre as aspas, espaço incluído. Não escreva string uma segunda vez para o mesmo nome. string plant = "leaf stem";, colocado sob uma linha que já criou plant, faz o build escrever um erro. Apague o segundo string e deixe plant = "leaf stem";.

Nada entre as aspas

Um par pode estar vazio. string plant = ""; tem a aspa de abertura e a aspa de fechamento, e nenhuma letra entre elas. A palavra de tipo ainda é string. O nome ainda é plant. O sinal = ainda guarda. O que guarda é nenhuma letra. Isso é permitido. O build não escreve erro para um par vazio. Console.WriteLine(plant); ainda roda. Escreve as letras que o nome guarda, e não há nenhuma, então a linha de tela não tem letras. A linha ainda termina. O programa ainda termina. Você pode ver uma linha em branco onde leaf teria estado. Essa linha em branco é a escrita. Não é uma espera, e não é falha de build.

Este é o terceiro arquivo. Não é o arquivo que você guarda. O arquivo que você guarda tem leaf entre as aspas. Guarde este terceiro arquivo só até ter visto a linha em branco, depois coloque "leaf" de volta entre as aspas.

Rode dotnet run. O par vazio é permitido, então o build não escreve erro. O programa escreve uma linha sem letras e termina. Não espera. Se você ainda vê leaf, as aspas ainda têm leaf entre elas. Depois de ver a linha em branco, faça a linha de guarda string plant = "leaf"; de novo.

Sem as aspas, leaf é um nome

O par faz o trabalho. Tire as duas aspas e a linha fica string plant = leaf;. Não há par, então leaf não é letras. C# lê leaf como um nome, e este arquivo não tem nome leaf. O build escreve um erro. Não fica quieto. Não há tela em que confiar enquanto o build escreve um erro. O conserto é colocar o par de volta, para a linha ser de novo string plant = "leaf";. Uma aspa só também não é um par. string plant = "leaf; abre as letras e nunca as fecha antes do ponto e vírgula. O build escreve erro nessa linha também. Coloque a aspa de fechamento de volta antes do ponto e vírgula.

Este quarto arquivo é o par faltando. Não é o arquivo que você guarda. Guarde-o só até o build escrever o erro, depois coloque as aspas de volta em volta de leaf.

Dois pedaços entre aspas unidos com plus

Uma linha de guarda pode unir dois pedaços entre aspas com +. A linha string plant = "leaf" + "stem"; tem dois pares. O primeiro par guarda leaf. O segundo par guarda stem. O + une essas letras em um valor: leafstem, sem espaço, porque nenhum par tinha espaço. A linha de escrita ainda é Console.WriteLine(plant);. A tela mostra leafstem em uma linha. Não são duas linhas de escrita. É uma só guarda que monta um conjunto de letras a partir de dois pedaços entre aspas.

Este é o quinto arquivo. Não é o arquivo que você guarda. O arquivo que você guarda tem um par e as letras leaf. Use esta quinta forma quando quiser ver a união, depois coloque o único par de volta.

A tela são as letras entre as aspas

Agora você pode guardar letras em um nome string e escrever essas letras sem colocar aspas na linha de escrita. string plant = "leaf"; guarda leaf. Console.WriteLine(plant); escreve leaf e termina a linha. Depois, plant = "leaf stem"; guarda o espaço como uma das letras. Aspas vazias não guardam letras e escrevem uma linha em branco. Sem as aspas, leaf é lido como nome e o build escreve um erro. "leaf" + "stem" une em leafstem. A próxima página fica com as letras e olha métodos que trabalham em um nome string, por exemplo perguntar quantas letras ele guarda.