Primer programa

Ya instalaste el SDK y ejecutaste un primer laboratorio. La pantalla mostró pine. Esta página se queda con la misma forma de programa y hace otra pregunta: qué línea dentro del archivo escribió esa palabra, y cuáles no escribieron nada. No estás instalando .NET otra vez. La línea de versión de la página anterior puede quedarse como estaba. Mantén la clase pública llamada Pine, mantén Main y mantén Console.WriteLine("pine");. La pantalla que estás explicando sigue siendo una línea, y esa línea es pine.

El archivo tiene más de una línea, así que la primera conjetura es que cada línea del archivo se convierte en una línea en la pantalla. Esa conjetura es incorrecta, y el resto de esta página muestra por qué. Varias líneas nombran algo. Solo una de ellas escribe. Las llaves agrupan esas líneas. Tampoco escriben. Cuando puedes señalar la línea de escritura con el archivo delante, esta página está hecha. La página siguiente añade una nota que la pantalla no muestra. No cambia pine.

using System prepara nombres cortos

La primera línea útil es using System;. Léela como línea de preparación, no como una frase que la pantalla va a imprimir. Trae nombres del espacio de nombres System en forma corta para que Console pueda aparecer sin una ruta larga. No ves la palabra using en la pantalla. No ves System en la pantalla. Borra esta línea en un experimento equivocado y el nombre corto Console puede fallar después — esa es una historia de compilación para otro día. En esta página la línea se queda, y la pantalla se queda pine porque esta línea no escribe.

La línea de clase nombra el tipo

La siguiente línea de tipo es public class Pine. Léela como tres palabras con un trabajo, no como texto de pantalla. public significa que otro código puede usar este tipo. No ves public en la pantalla. class significa que este archivo define una unidad con nombre. No ves class en la pantalla. Pine es el nombre de esa unidad. En esta forma didáctica el nombre base del archivo coincide con ese nombre. Cambia el nombre en esta línea y el hábito del nombre de archivo tiene que cambiar con él. Esa regla es sobre el tipo y el archivo. No es sobre la pantalla. Mira la pantalla otra vez. La pantalla no muestra Pine. Muestra pine. La P mayúscula y la p minúscula no son la misma palabra. La línea de clase nunca escribe su nombre en la pantalla.

El carácter después de esa línea es una llave de apertura {. La llave de cierre correspondiente más adelante en el archivo termina el cuerpo de la clase. Todo entre esas llaves pertenece a la clase Pine. Las llaves son cercas. Le dicen a C# dónde empieza esta unidad y dónde termina. Una cerca no es texto para la pantalla. No verás { ni } junto a pine. Si borras la llave de apertura, el archivo está roto y el compilador escribe un error en lugar de quedarse callado. Ese error no es esta página. Esta página mantiene ambas llaves, y la pantalla se queda pine.

La línea Main es donde el runtime empieza

La siguiente línea es public static void Main(). Esta es la línea a la que la gente señala cuando les preguntan dónde empieza el programa, y tienen razón sobre el inicio. Se equivocan si después dicen que la pantalla muestra Main. El runtime busca un método con esta forma cuando ejecutas el proyecto. Empieza a ejecutarse en esta línea. Empezar no es lo mismo que escribir. Las palabras de la línea son instrucciones sobre cómo empezar. No son palabras para la pantalla.

Toma las palabras una a una y comprueba cada una contra la pantalla. public otra vez significa que el método se puede iniciar desde fuera. static significa que el runtime puede iniciar este método sin construir primero un objeto. Aún no has conocido los objetos, así que el único hecho que necesitas es que static es obligatorio en esta forma didáctica y que no se imprime. void significa que este método no devuelve un valor a quien lo llama. No hay historia de llamador en esta página, y void no está en la pantalla. Main es el nombre que el runtime busca en esta forma. La pantalla todavía no muestra esas cuatro letras. Los paréntesis marcan la lista de parámetros. En esta página la lista está vacía. Los paréntesis vacíos tampoco imprimen.

Así que la línea Main puede ser cierta de dos maneras a la vez. El runtime sí empezó ahí. La pantalla no recibió ni una sola palabra de esa línea. Si tus ojos se quedan en Main porque está en el medio del archivo, muévelos. La palabra que recuerdas de la pantalla es pine, y pine no está escrito en esta línea.

La línea interior escribe pine

Dentro de Main, entre sus propias llaves, hay una línea más. Esa línea es Console.WriteLine("pine");. Esta es la línea que escribe la pantalla. Está sangrada en el archivo para que veas que está dentro de Main. La sangría son espacios. Los espacios tampoco se escriben en la pantalla. El runtime ejecuta esta línea interior porque está dentro del método donde empieza el programa. La pantalla usa lo que escribe esta línea interior. No usa el nombre del método exterior.

Lee la línea interior de izquierda a derecha. Console es el ayudante de pantalla que usa este curso. WriteLine significa escribe esto, luego termina la línea. La parte entre paréntesis es lo que se escribe. Dentro de los paréntesis la palabra pine está entre comillas dobles. Las comillas marcan pine como texto. No forman parte del texto. Quítalas en tu cabeza y la palabra que queda es pine, y eso es toda la pantalla. Déjalas en el archivo. Sin las comillas, el compilador no trata pine como ese literal de texto. El punto y coma al final termina la sentencia para C#. No ves un punto y coma en la pantalla. Ves pine, y luego la línea termina porque WriteLine la terminó.

Aquí está esa línea de escritura sola, para que las otras líneas no la oculten.

Nada en el comando dotnet run elige la palabra pine. El comando solo inicia el proyecto. La palabra viene de las comillas. Si las comillas tuvieran otra palabra, la pantalla mostraría esa palabra en su lugar, y esta página no hace eso. Las comillas de esta página tienen pine, así que la pantalla es pine. Una línea. Sin segunda línea. Sin comillas en la pantalla. Sin la palabra Main. Sin la palabra Pine.

Qué malinterpreta la gente

El error habitual es leer el archivo de arriba abajo y asumir que la palabra más familiar es la salida. Main parece importante, y lo es, porque el runtime no iniciará esta forma sin él. Importancia no es salida. Puedes tapar la línea Main con un dedo y la línea de escritura sigue siendo Console.WriteLine("pine");. No puedes tapar la línea de escritura y seguir explicando la pantalla. Otro error es decir que la pantalla muestra Pine porque la clase se llama Pine. La pantalla usa la palabra entre las comillas, y esa palabra se escribe con p minúscula. Un tercer error es contar líneas. El archivo muestra varias líneas y varias llaves. La pantalla muestra una. Las llaves, las palabras public y static y void, el nombre Main, el nombre Pine y using System; siguen en el archivo después de la ejecución. La ejecución no los borra. Tampoco los imprime.

La pantalla viene de una línea

Puedes poner un dedo en Console.WriteLine("pine"); y decir que de esta línea viene la pantalla. Puedes poner un dedo en public static void Main() y decir que el runtime empieza ahí y que la palabra Main no está en la pantalla. Puedes poner un dedo en public class Pine y decir que este nombre coincide con el tipo didáctico y no con la pantalla. La página siguiente pone una nota en el archivo. La nota es para una persona que lee el archivo. La pantalla seguirá siendo pine, porque la nota no es un segundo WriteLine.
Mantén lejos de esta página los hábitos sobrantes de Java con System.out.println("mint") cuando practiques la línea de escritura de C#. Mantén lejos de esta página inventar rutas ASP.NET. Mantén lejos de esta página tratar dotnet --version como la palabra de pantalla — la línea de versión fue prueba de instalación, no la salida de este programa. Cuando puedas nombrar la línea de escritura y rechazar las conjeturas falsas de Main y Pine, First Program hizo su trabajo y estás listo para C# Comments si continúas.