Entrada

Teclea leaf después de que el programa haya arrancado, y la pantalla muestra leaf. Esa palabra no está en el archivo. El archivo Pine crea un nombre, plant, y espera. Tecleas leaf y pulsas Enter. Console.WriteLine(plant) escribe leaf. Hasta ahora una pantalla distinta significaba editar la línea de guardado, porque la palabra vivía en el archivo entre comillas. Mantén el nombre de la clase pública Pine. Tú no vuelves a instalar el SDK.

El archivo espera una línea tecleada

Abre el archivo Pine. El nombre de la clase sigue siendo Pine. Esta página no renombra el tipo. Dentro de Main, sustituye la antigua línea de guardado que llevaba comillas. La nueva línea de guardado es string plant = Console.ReadLine();. La palabra clave string sigue diciendo que este nombre guarda letras. plant sigue empezando con p minúscula. El signo = sigue guardando letras en ese nombre. Lo nuevo es el lado derecho. Console.ReadLine() no tiene comillas. No hay leaf en esta línea. La línea pide a la consola una línea tecleada. El programa espera ahí hasta que pulses Enter. Cuando pulsas Enter, ReadLine guarda las letras que tecleaste antes de ese Enter. No guarda el Enter en sí. Luego la línea termina en el punto y coma. Guardar todavía no es escribir. El programa aún no ha escrito su propia línea.

La línea de escritura sigue siendo el nombre desnudo, la misma forma que el archivo que guardaste en la página anterior: Console.WriteLine(plant);. Sin comillas. C# lee el nombre plant, escribe las letras que ese nombre guarda y termina la línea. Esas letras son lo que ReadLine acaba de guardar. Si tecleaste leaf, el programa escribe leaf. Si tecleaste stem, el programa escribe stem. El archivo no cambió entre esas dos ejecuciones. Guarda el archivo.

El archivo que conservas

Conserva esta forma didáctica. La palabra que vas a teclear no está en el archivo. Busca en el archivo las letras l, e, a, f. No están ahí. La línea guardada se llama plant. La línea de escritura usa plant y no contiene comillas.

Lee el archivo de arriba abajo y decide qué puede llegar a la pantalla. using System; prepara nombres cortos. public class Pine nombra el tipo. public static void Main() es donde arranca el runtime. Ninguna de esas palabras son letras para la pantalla. string plant = Console.ReadLine(); guarda una línea tecleada en plant. Por sí sola no escribe nada. Console.WriteLine(plant); es la única línea de escritura. Escribe las letras guardadas y termina la línea. El nombre plant no se escribe. Console no se escribe. El punto y coma no se escribe.

Lo que tecleas y lo que escribe el programa

Ejecútalo con dotnet run. Tras ese comando, el programa espera en Console.ReadLine(). Aún no ha terminado y no ha escrito leaf, porque todavía no le has dado una línea. El cursor está en una línea nueva. Teclea las letras l, e, a, f. El terminal muestra esas letras mientras pulsas las teclas. Ese mostrar es el terminal repitiendo tus teclas. No es Console.WriteLine. Luego pulsa Enter.

Enter termina la espera. ReadLine guarda leaf en plant y no guarda el Enter. WriteLine escribe entonces leaf y termina la línea. Puedes ver leaf, y debajo otra vez leaf. El primero son las teclas que mostró el terminal. El segundo es la línea del programa. La línea del programa no tiene comillas. Son cuatro letras, y luego termina la línea. El programa termina tras esa línea de escritura. Si el único leaf que quieres juzgar es la línea del programa, juzga la línea que aparece después de pulsar Enter.

Si la línea del programa es plant, la línea de escritura tiene comillas alrededor de plant. El archivo que conservas no. Si dotnet run escribe leaf de inmediato y nunca espera, el archivo sigue guardando una palabra entre comillas, como string plant = "leaf";, y nunca llama a ReadLine. Busca comillas alrededor de leaf. El archivo que conservas no tiene ninguna. No reinstales el .NET SDK por una pantalla que muestra la palabra equivocada.

Las mayúsculas se copian tal como las tecleas. Si tecleas Leaf con L mayúscula y pulsas Enter, la línea del programa es Leaf. El archivo sigue sin contener esas letras. Un Enter vacío también es una línea real. Pulsa Enter sin teclear letras. ReadLine no guarda letras en plant. WriteLine escribe una línea sin letras. El programa se ejecutó. La espera terminó porque llegó Enter. El archivo que conservas es el que pruebas con leaf, cuatro letras minúsculas.

Un espacio se queda en la línea

ReadLine lee hasta Enter, no hasta un espacio. Teclea leaf, luego un espacio, luego stem, luego Enter. Las letras guardadas en plant son leaf, un espacio y stem. Console.WriteLine(plant) escribe leaf stem. El espacio es un carácter guardado, igual que un espacio entre comillas se guardaba cuando la palabra vivía en el archivo. Esta página no corta la línea en el espacio. El archivo que conservas sigue siendo el lector de una sola línea. Solo cambias lo que tecleas, no el archivo, cuando quieres el espacio en la pantalla.

Dos líneas tecleadas, dos Enter

Un programa puede tomar una segunda línea. Bajo la primera línea de escritura, guarda una línea nueva en el mismo nombre y luego escribe el nombre otra vez. La nueva línea de guardado es plant = Console.ReadLine();. No empieza con string. plant ya existe, así que esta línea solo sustituye las letras que el nombre guarda. La siguiente línea de escritura es otra vez Console.WriteLine(plant);. El programa ahora espera dos veces. Cada ReadLine espera su propio Enter.

Este es el segundo archivo. No es el archivo que conservas. El archivo que conservas espera una vez y escribe una vez. Usa esta segunda forma cuando quieras dos líneas tecleadas, y luego vuelve a poner el único ReadLine y el único WriteLine.

Ejecuta dotnet run. El programa espera. Teclea leaf y pulsa Enter. El terminal muestra leaf, y el programa escribe leaf debajo. El programa espera otra vez. Aún no ha terminado. Teclea stem y pulsa Enter. El terminal muestra stem, y el programa escribe stem debajo. Las líneas del programa son leaf, luego stem. Las teclas eco quedan encima de cada una de esas líneas. Si las dos líneas del programa dicen leaf, el segundo ReadLine no se ejecutó, o tecleaste leaf las dos veces. Si el programa escribe stem antes de que hayas tecleado una segunda línea, el segundo WriteLine no está bajo un segundo ReadLine. La pantalla sigue el orden de las líneas del archivo, y cada espera sigue al ReadLine que aún no ha recibido Enter.

No escribas string una segunda vez para el mismo nombre. string plant = Console.ReadLine(); bajo una línea que ya creó plant es otro error. Esa línea intenta crear plant otra vez. La compilación escribe un error y no se queda en silencio. La reparación es borrar el segundo string y dejar plant = Console.ReadLine();. El nombre se crea una vez. Las líneas posteriores solo cambian las letras que guarda. En el archivo que conservas no hay un segundo ReadLine en absoluto.

Las comillas alrededor del nombre escriben el nombre

La línea de escritura en el archivo que conservas es Console.WriteLine(plant); sin comillas. Si pones comillas alrededor del nombre después de una línea tecleada real, la línea es Console.WriteLine("plant");. Esas comillas marcan letras para la pantalla. Las letras entre ellas son p, l, a, n, t. C# no busca el nombre. Puedes teclear leaf y pulsar Enter, y ReadLine puede guardar leaf en plant, y la línea del programa sigue mostrando plant. La palabra tecleada no se escribe, porque la línea de escritura nunca usó el nombre.

Este es el tercer archivo. No es el archivo que conservas. Consérvalo el tiempo suficiente para ver la única línea del programa plant después de teclear leaf, y luego quita las comillas de la línea de escritura otra vez.

El nombre tiene que existir después de ReadLine

C# lee el archivo de arriba abajo. La línea que llena plant tiene que estar por encima de la línea que escribe plant. Si pones primero Console.WriteLine(plant); y solo después escribes string plant = Console.ReadLine();, la línea de escritura nombra plant antes de que plant exista. La compilación escribe un error. No se queda en silencio. No hay pantalla de confianza mientras la compilación escribe un error. La reparación es volver a poner la línea ReadLine encima de la línea de escritura.

Este cuarto archivo es el orden roto. No es el archivo que conservas. Consérvalo solo hasta que la compilación escriba el error, y luego vuelve a poner la línea ReadLine arriba.

WriteLine no guarda una línea tecleada

La línea de guardado debe llamar a ReadLine, no a WriteLine. Si la línea es string plant = Console.WriteLine();, la compilación escribe un error. WriteLine escribe en la pantalla y no devuelve letras a un nombre. No es un almacén que espera. No hay un leaf tecleado en el que confiar mientras la compilación escribe un error. La reparación es volver a poner Console.ReadLine() a la derecha de =.

Este quinto archivo es la llamada de guardado incorrecta. No es el archivo que conservas. Consérvalo solo hasta que la compilación escriba el error, y luego vuelve a poner ReadLine.

La pantalla es la línea que tecleaste

Ahora puedes llenar un nombre desde el teclado y escribir esa línea sin poner la palabra entre comillas en el archivo. string plant = Console.ReadLine(); espera Enter y guarda las letras tecleadas. Console.WriteLine(plant); escribe esas letras y termina la línea. Un segundo ReadLine espera otra vez. Las comillas alrededor del nombre escriben las letras del nombre en su lugar. La línea ReadLine tiene que sentarse por encima de la primera línea que usa el nombre. WriteLine en el lado de guardado no es un almacén. La página siguiente empieza Value Types, para que un nombre pueda guardar un número con un tipo distinto de string, mientras esta página se queda en una línea tecleada de letras.