Comentarios

Una nota en el programa Pine es para la persona que lee el archivo. La pantalla sigue siendo pine. Console.WriteLine("pine"); sigue siendo la línea que escribe esa palabra. Esta página añade la nota en dos formas, muestra que pine sigue siendo la única línea y luego muestra el único lugar que quita pine. No estás instalando el SDK otra vez. No estás releuyendo qué línea es Main. Mantén la clase pública llamada Pine y mantén el comando de escritura activo en el archivo que guardas.

Una nota no es un comando

Un comando es una línea que C# ejecuta. Console.WriteLine("pine"); es un comando. Escribe pine y termina la línea. Una nota es texto que dejas en el archivo para que tú, o el siguiente lector, recuerden algo. El compilador y el tiempo de ejecución saltan una nota. Saltar significa que la nota no se ejecuta y no se escribe en la pantalla. Las letras de la nota siguen en el archivo después de la ejecución. Puedes abrir el archivo y leerlas. No las encuentras en la pantalla. La pantalla sigue teniendo una línea, y esa línea es pine, mientras el comando de escritura en sí no sea la nota.

Hay dos formas. Una nota de línea empieza con dos barras, //. C# salta desde esas dos barras hasta el final de esa misma línea. La siguiente línea vuelve a ser una línea normal. Una nota de bloque empieza con /* y termina en el primer */. C# salta todo lo que hay entre esas dos marcas, incluidos los saltos de línea. Una nota de bloque puede estar en una línea o atravesar varias. Ambas formas son notas. Ninguna escribe la pantalla. Las barras no se imprimen. Las estrellas no se imprimen. Las palabras que pones entre ellas no se imprimen.

El archivo que guardas

Conserva esta forma de enseñanza. Tiene una nota de línea encima del comando de escritura, otra nota de línea en la propia línea del comando y una nota de línea cerca de Main. El comando de escritura sigue ahí y no está detrás de una barra.

Léelo desde arriba y decide para cada línea si la pantalla la recibe. La línea using System; prepara nombres cortos y no escribe la pantalla. La línea de clase sigue siendo public class Pine. Esa línea nombra el tipo y no escribe la pantalla. La siguiente línea es // the teaching type is Pine. Las dos barras empiezan una nota, así que esas palabras son para ti. La pantalla no las muestra. Tampoco muestra las barras. La línea public static void Main() es donde empieza el tiempo de ejecución, y ninguna de esas palabras está en la pantalla. Eso no ha cambiado respecto a First Program.

Dentro de Main, la línea // a note for the reader es solo una nota. El tiempo de ejecución la alcanza, la salta y pasa a la siguiente línea. La siguiente línea es la que importa: Console.WriteLine("pine"); // the screen is this word. Lee esa línea como dos partes separadas por las barras. Antes de las barras, el comando es Console.WriteLine("pine");. Ese comando escribe pine y termina la línea. Después de las barras, las palabras the screen is this word son una nota. Se sientan en la misma línea que el comando y aun así se saltan. Una nota no tiene que ocupar una línea entera ella sola. Si // aparece después de un comando terminado, el comando se ejecuta y el resto de la línea no. El punto y coma es lo que termina el comando. Las barras después del punto y coma empiezan la nota. Deja ese punto y coma donde está. La pantalla muestra pine. No muestra the screen is this word. No muestra una segunda línea.

Ejecútalo igual que después de la instalación. En la carpeta del proyecto escribe dotnet run. La pantalla muestra pine. Una línea. Sin comillas. Sin barras. Sin segunda línea. La palabra pine sigue siendo la palabra entre las comillas. No es una palabra que escribiste en el comando ni una palabra que escribiste en una nota. Las notas no hacen fallar la compilación y no se imprimen a sí mismas.

Una nota de bloque

Una nota de bloque es la otra forma. La usas cuando la nota es más larga que una línea, o cuando quieres que el final de la nota sea una marca que eliges tú, no el final de la línea. La marca de apertura es /*. La marca de cierre es */. C# salta desde la apertura hasta el cierre, y el primer */ es el final. Un */ posterior no forma parte de esta nota, porque la nota ya terminó. Esta página usa una nota de bloque, así que verás una apertura y un cierre.

Sustituye las notas de línea dentro de Main por una nota de bloque y deja el comando de escritura en su sitio. La pantalla no cambia. Este es el segundo archivo. Estás mirando cómo se ve la nota. El archivo que guardabas usaba notas de línea. Este usa una nota de bloque. Ambos escriben pine.

La nota de bloque empieza en la línea que comienza con /*. Las palabras a note están dentro. La siguiente línea, across two lines, también está dentro, porque el */ de cierre aún no ha aparecido. El */ al final de esa segunda línea termina la nota. Luego C# ejecuta Console.WriteLine("pine"); porque ese comando está fuera de la nota, debajo de la marca de cierre. La pantalla muestra pine. Las palabras a note y across two lines no están en la pantalla. Las estrellas y las barras no están en la pantalla. Si mueves el */ hacia arriba para que quede en la primera línea, justo después de a note, entonces la segunda línea ya no está dentro de la nota. Esa segunda línea tendría que ser una línea C# real, y across two lines no es un comando. La compilación escribiría un error en lugar de quedarse en silencio. En esta página el */ se queda al final de la segunda línea, así que se salta toda la nota y la compilación se queda en silencio.

No intentes poner una nota de bloque dentro de otra. El primer */ termina la nota, aunque quisieras que ese */ terminara una nota interior. Después de esa primera marca de cierre, C# vuelve a leer comandos. Esta página no anida notas. Una apertura, un cierre, luego el comando de escritura.

El error que quita pine

La nota y el comando de escritura son líneas distintas, o partes distintas de una línea, en los archivos de arriba. El error es poner las dos barras delante del comando de escritura, de modo que el comando se convierte en la nota. Guarda esta tercera forma solo el tiempo suficiente para ver la pantalla vacía y luego vuelve a poner el comando de escritura. Este no es el archivo que guardas.

dotnet run entonces no escribe nada útil en la pantalla para esta comprobación de enseñanza. No hay pine. No hay una palabra entre comillas vacía. No hay una segunda línea. La pantalla está en blanco porque el comando que escribía pine está detrás de //. Las letras Console.WriteLine("pine") siguen en el archivo y puedes leerlas, pero ahora son una nota. Las comillas no las salvan. Las comillas marcan una palabra dentro de un comando. No convierten una nota otra vez en comando. Las dos barras del frente deciden, y deciden que el resto de la línea es para el lector.

Devuelve el archivo al que guardas. La línea de escritura debe ser Console.WriteLine("pine"); con la nota, si quieres una, después del punto y coma. Luego dotnet run vuelve a escribir pine. Si la pantalla está en blanco, busca // delante de Console. Esa es toda la comprobación. No reinstalas el .NET SDK por una pantalla en blanco causada por una nota. Mantén fuera de esta página los hábitos restantes de Java con System.out.println cuando practiques la línea de escritura de C#. Mantén inventar rutas ASP.NET fuera de esta página.

La pantalla sigue siendo pine

Ya puedes poner una nota en el archivo Pine sin cambiar la pantalla. Una nota de línea empieza con //. Una nota de bloque empieza con /* y termina en el primer */. La pantalla del archivo que guardas es pine, escrita por Console.WriteLine("pine");. Si // se pone delante de ese comando, la pantalla no tiene línea. Una nota puede contener cualquier palabra, incluidas Pine, Main y pine. Esas palabras siguen sin estar en la pantalla. La página siguiente cambia cómo se escriben las líneas de salida, para que la pantalla pueda mostrar más de un hábito corto. Las notas de esta página siguen siendo notas.