Cadenas

string plant = "leaf"; guarda las cuatro letras leaf, y Console.WriteLine(plant) escribe leaf. Las comillas quedan en el archivo. No están en la pantalla. La página anterior guardó el número entero 4 sin comillas alrededor. Aquí el par de comillas es lo que guarda las letras, y un par faltante hace que el build escriba un error. Mantén el nombre de la clase pública Pine. Tú no vuelves a instalar el SDK.

Las comillas guardan las letras

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. La página anterior mantuvo int count = 4; sin comillas y sin teclado. Esta página no conserva ese número. Borra la línea int si todavía está. Borra cualquier línea ReadLine. El archivo que conservas no tiene espera ni línea de número entero. Las letras solo las escribe la línea de escritura que usa el nombre.

Dentro de Main, la línea de guardado es string plant = "leaf";. string es la palabra de tipo. Dice que este nombre guarda letras. plant es el nombre y empieza con p minúscula. El signo = guarda las letras. Luego viene el par. La primera comilla abre las letras. Las cuatro letras son l, e, a, f, en ese orden, todas minúsculas. La segunda comilla cierra las letras. Entre esas dos comillas no hay nada más: ni espacio, ni letra extra, ni segunda palabra. El punto y coma termina la línea. Esta línea no escribe la pantalla. Guardar no es escribir. La pantalla sigue en blanco a lo largo de esta línea. Las comillas forman parte de la línea de guardado. No forman parte del valor que el nombre guarda después de que la línea lo ha guardado.

La línea de escritura es el nombre desnudo: Console.WriteLine(plant);. Sin comillas. C# lee el nombre plant, escribe las letras que ese nombre guarda y termina la línea. Para el archivo que conservas, esas letras son l, e, a, f. Las marcas de comillas no están en la pantalla. Las letras del nombre, p, l, a, n, t, no están en la pantalla. string no está en la pantalla. Console no está en la pantalla. El punto y coma no está en la pantalla. Guarda el archivo.

El archivo que conservas

Conserva esta forma didáctica. Una palabra de tipo, string. Un nombre, plant. Un par de comillas. Cuatro letras entre ellas, leaf. Una línea de escritura, y esa línea usa el nombre desnudo.

Léelo desde arriba. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el tiempo de ejecución. Ninguna de esas palabras son las letras de la pantalla. La línea de guardado es string plant = "leaf";. Esa línea guarda las letras. No escribe nada. Console.WriteLine(plant); es la única línea de escritura. Escribe leaf y termina la línea. Una línea. Sin marcas de comillas en esa línea de pantalla.

Ejecútalo con dotnet run. El programa escribe leaf. No espera a que escribas. Las letras ya estaban en el archivo. Si dotnet run espera, el archivo todavía tiene ReadLine. Borra esa línea y conserva string plant = "leaf";. La pantalla muestra leaf, una línea, cuatro letras, sin marcas de comillas. Si la pantalla muestra plant, la línea de escritura tiene comillas alrededor del nombre: Console.WriteLine("plant");. Esas comillas marcan las letras p, l, a, n, t. C# no busca el nombre, así que el leaf guardado no se escribe. El archivo que conservas tiene el nombre desnudo en la línea de escritura y las comillas alrededor de leaf en la línea de guardado. Si la pantalla muestra 4, el archivo todavía tiene el número entero de la página anterior. El archivo que conservas tiene leaf, no 4. Tú no reinstalas el .NET SDK por una pantalla que muestra la línea equivocada.

Una letra mayúscula entre las comillas se guarda como esa mayúscula. string plant = "Leaf"; haría que la línea de escritura escribiera Leaf, con L grande. El archivo que conservas no usa eso. Usa cuatro letras minúsculas. Juzga la pantalla por las letras que realmente se sientan entre las comillas, no por una palabra que solo pretendías escribir.

Un espacio es una de las letras

La línea de escritura puede quedarse en su sitio mientras cambian las letras entre las comillas. Bajo la primera línea de escritura, guarda un nuevo conjunto de letras en el mismo nombre y luego escribe el nombre otra vez. La nueva línea de guardado es plant = "leaf stem";. No empieza con string. plant ya existe, así que esta línea solo reemplaza las letras que el nombre guarda. Entre las comillas esta vez hay nueve caracteres: l, e, a, f, un espacio, s, t, e, m. El espacio es uno de ellos. No es un corte en dos líneas de guardado, y no se borra cuando se escribe la pantalla. La siguiente línea de escritura es otra vez Console.WriteLine(plant);. La pantalla ahora tiene dos líneas. La primera es leaf, de las letras que el nombre guardaba en ese momento. La segunda es leaf stem, de las letras que el nombre guarda después de plant = "leaf stem";. Un espacio se sienta entre leaf y stem en esa segunda línea. Las dos palabras no están en dos líneas separadas.

Este es el segundo archivo. No es el archivo que conservas. El archivo que conservas tiene una línea de guardado, las letras leaf y sin espacio. Usa esta segunda forma cuando quieras ver el espacio, luego vuelve a poner la única línea de guardado y la única línea de escritura.

Ejecuta dotnet run. La pantalla muestra leaf, y la línea siguiente es leaf stem. Dos líneas. Sin marcas de comillas. El nombre plant no está en ninguna. Si la segunda línea es leafstem, sin hueco, falta el espacio entre las comillas. Si ambas líneas son leaf, falta la segunda línea de guardado o todavía dice "leaf". La pantalla sigue el orden de las líneas del archivo y sigue las letras entre las comillas, espacio incluido. No escribas string una segunda vez para el mismo nombre. string plant = "leaf stem";, bajo una línea que ya creó plant, hace que el build escriba un error. Borra el segundo string y deja plant = "leaf stem";.

Nada entre las comillas

Un par puede estar vacío. string plant = ""; tiene la comilla de apertura y la de cierre, y ninguna letra entre ellas. La palabra de tipo sigue siendo string. El nombre sigue siendo plant. El signo = sigue guardando. Lo que guarda es ninguna letra. Esto está permitido. El build no escribe un error por un par vacío. Console.WriteLine(plant); sigue ejecutándose. Escribe las letras que el nombre guarda, y no hay ninguna, así que la línea de pantalla no tiene letras. La línea termina igual. El programa termina igual. Puedes ver una línea en blanco donde habría estado leaf. Esa línea en blanco es la escritura. No es una espera ni un fallo de build.

Este es el tercer archivo. No es el archivo que conservas. El archivo que conservas tiene leaf entre las comillas. Conserva este tercer archivo solo hasta que hayas visto la línea en blanco, luego vuelve a poner "leaf" entre las comillas.

Ejecuta dotnet run. El par vacío está permitido, así que el build no escribe error. El programa escribe una línea sin letras y termina. No espera. Si todavía ves leaf, las comillas todavía tienen leaf entre ellas. Después de ver la línea en blanco, haz que la línea de guardado sea otra vez string plant = "leaf";.

Sin las comillas, leaf es un nombre

El par hace el trabajo. Quita ambas comillas y la línea queda string plant = leaf;. No hay par, así que leaf no son letras. C# lee leaf como un nombre, y este archivo no tiene un nombre leaf. El build escribe un error. No se queda callado. No hay pantalla en la que confiar mientras el build escribe un error. La reparación es volver a poner el par, de modo que la línea sea otra vez string plant = "leaf";. Una sola comilla tampoco es un par. string plant = "leaf; abre las letras y nunca las cierra antes del punto y coma. El build escribe un error por esa línea también. Vuelve a poner la comilla de cierre antes del punto y coma.

Este cuarto archivo es el par faltante. No es el archivo que conservas. Consérvalo solo hasta que el build escriba el error, luego vuelve a poner las comillas alrededor de leaf.

Dos piezas entre comillas unidas con plus

Una línea de guardado puede unir dos piezas entre comillas con +. La línea string plant = "leaf" + "stem"; tiene dos pares. El primer par guarda leaf. El segundo par guarda stem. El + une esas letras en un valor: leafstem, sin espacio, porque ninguno de los pares tenía espacio. La línea de escritura sigue siendo Console.WriteLine(plant);. La pantalla muestra leafstem en una línea. No son dos líneas de escritura. Es un solo guardado que construye un conjunto de letras a partir de dos piezas entre comillas.

Este es el quinto archivo. No es el archivo que conservas. El archivo que conservas tiene un par y las letras leaf. Usa esta quinta forma cuando quieras ver la unión, luego vuelve a poner el par único.

La pantalla son las letras entre las comillas

Ahora puedes guardar letras en un nombre string y escribir esas letras sin poner comillas en la línea de escritura. string plant = "leaf"; guarda leaf. Console.WriteLine(plant); escribe leaf y termina la línea. Más adelante plant = "leaf stem"; guarda el espacio como una de las letras. Las comillas vacías no guardan letras y escriben una línea en blanco. Sin las comillas, leaf se lee como un nombre y el build escribe un error. "leaf" + "stem" se une en leafstem. La página siguiente sigue con letras y mira métodos que trabajan sobre un nombre string, como preguntar cuántas letras guarda.