Introducción a C#

Abre un archivo pequeño de C# y predice la única palabra que escribe en pantalla. En Pine.cs mantén una clase pública llamada Pine, mantén un método Main y llama a Console.WriteLine("pine");. Cuando el archivo se ejecuta, la pantalla muestra pine. Las comillas se quedan en el archivo. El nombre de clase Pine no sale en pantalla. Deja la instalación del SDK de .NET y los comandos de ejecución para la página siguiente. Esta lección es el primer archivo y su línea de pantalla, no un sitio ASP.NET ni una escena de Unity.

Un archivo, una palabra en pantalla

C# es un lenguaje para programas que guardas en un archivo y ejecutas desde una terminal en .NET. La terminal es la ventana donde escribes un comando y lees las líneas que devuelve. Este curso se queda con esos archivos de consola. Escribes un archivo, lo ejecutas y lees la pantalla. No estás construyendo una página web en esta página. No estás abriendo un editor de juegos en esta página.
Nombra el archivo didáctico Pine.cs. Mantén el nombre de clase pública Pine para que la clase y la raíz del archivo coincidan en esta forma de principiante. Dentro de Main escribe una palabra en pantalla:
Console.WriteLine("pine");
Esa llamada es la línea de escritura. La palabra entre comillas es pine. Cuando el programa corre, esa palabra es lo que muestra la pantalla. Mantén las comillas en el archivo para que C# trate pine como texto. No inventes una segunda impresión en esta página. Una palabra clara en pantalla basta para la introducción.

Recorre el archivo una vez con la vista. Las primeras líneas útiles traen System con using System; para que nombres cortos como Console funcionen. public class Pine nombra el tipo. public static void Main() marca la entrada que inicia el runtime. Console.WriteLine("pine"); escribe la línea de pantalla. Cuando este archivo corre, la pantalla muestra pine. No hay segunda línea. Nada queda al lado de pine en esa línea.
Di la regla de principiante mientras miras la línea de escritura: la pantalla usa la palabra entre comillas, no el nombre de clase en la línea de tipo. Pine con P mayúscula es la clase. pine con p minúscula es la palabra de pantalla. No son el mismo token. Si aún escuchas mint de una demo sobrante de introducción a Java, déjala en otro curso y mantén pine aquí.

El nombre de clase no es la pantalla

La primera línea de tipo es public class Pine. Mira la pantalla otra vez tras ejecutar. La pantalla no muestra Pine. Muestra pine. La mayúscula y la minúscula marcan palabras distintas. Los principiantes suelen señalar el nombre de clase y adivinar que la pantalla coincidirá. En esta página esa suposición falla. La línea de escritura decide la pantalla. La línea de escritura es Console.WriteLine("pine");.
Otras líneas del archivo importan después. using System; prepara nombres cortos. Main es la entrada. Las llaves agrupan el cuerpo del método. Esas líneas forman parte del programa. No se copian en pantalla como texto. Una página posterior lee comandos de instalación y ejecución. En esta página eres responsable de nombrar la palabra de pantalla y la línea de escritura que la produce.

Hábitos de archivo para el primer programa

Mantén fácil de distinguir el nombre de archivo, el nombre de clase, la línea de escritura y la palabra de pantalla.

C# aquí no es ASP.NET

ASP.NET construye aplicaciones web. Unity construye juegos. Este tutorial enseña programas pequeños de consola: una clase, Main, tipos, decisiones, bucles, métodos, objetos, listas, archivos y un error capturado en la ruta principal. Mantén esos otros productos fuera de esta introducción. Si una tarjeta de inicio sobrante aún habla de todo el ecosistema .NET, el trabajo didáctico de hoy sigue siendo una palabra de pantalla desde Pine.cs.
Sin Console.WriteLine, esta forma didáctica no tiene línea de pantalla. Sin comillas alrededor de pine, la línea de escritura ya no es ese literal de texto. Sin Main, el runtime no tiene entrada en esta forma. Mantén juntos la línea de escritura, las comillas y Main cuando practiques leer el archivo.

Leer antes de instalar

Estás leyendo el archivo en esta página. Aún no instalas el SDK. Aún no escribes dotnet run. La página siguiente instala C# / .NET en el equipo y ejecuta un primer archivo. Tras esa ejecución, la pantalla que te importa sigue siendo una palabra corta como pine si mantienes esta forma de escritura. Hoy predices la pantalla desde las comillas. Mañana instalas y ejecutas.
Si el archivo aún dice Console.WriteLine("Pine"); con P mayúscula dentro de las comillas, la pantalla mostraría Pine, no pine. Restaura el literal didáctico pine para esta página y así el nombre de clase y la palabra de pantalla siguen fáciles de contrastar. Si pegaste una línea Java System.out.println("mint") en un archivo .cs, vuelve a Console.WriteLine("pine"); — esa es la llamada de escritura de C# en este curso.

Antes de Install C

Puedes mantener la clase pública Pine, mantener Main, importar System, llamar a Console.WriteLine("pine"); y decir que la pantalla mostrará pine sin comillas y sin segunda línea. La tabla separa archivo, clase, entrada, línea de escritura y pantalla. La página siguiente es Install C#.
Mantén la demo Pine para una primera palabra de pantalla clara. Mantén carpetas ASP.NET fuera de esta página cuando practiques la introducción. Mantén fuera de esta página inventar demos largas con varias impresiones. Esos hábitos son el punto de control antes de instalar. Cuando puedes señalar Console.WriteLine("pine"); y nombrar la pantalla pine, la introducción hizo su trabajo y estás listo para Install C# si continúas.
Un último repaso del archivo: using System; presente, clase pública Pine, Main presente, línea de escritura con "pine", sin historia de Scanner de otros lenguajes, sin ruta web obligatoria. Lee la línea de escritura una vez más. Si la palabra entre comillas sigue siendo pine, la primera forma de C# es sólida y el curso puede pasar a instalar en la página siguiente. Prefiere una palabra de pantalla clara por lectura para que cada paso enseñe el mismo mapa.
Lee las llaves una vez como marcas de agrupación, no como texto de pantalla. Lee el punto y coma al final de Console.WriteLine("pine"); como el fin de esa sentencia, no como un carácter que imprime la pantalla. Mantén el archivo didáctico lo bastante corto para que una línea de escritura siga fácil de encontrar. Cuando esos hábitos se mantienen, puedes abrir Install C# sin arrastrar una suposición errónea de pantalla desde esta página.