Con el entorno de desarrollo ya preparado, ha llegado el momento de crear tu primer proyecto real: BiblioTechConsola, la primera piedra del sistema BiblioTech que construiremos a lo largo de todo el curso. En esta lección crearás el proyecto paso a paso, escribirás y ejecutarás un "Hola Mundo", y analizaremos línea a línea cada parte del código, incluyendo tanto la forma clásica como la forma moderna (top-level statements) de escribirlo. Entender bien esta estructura mínima es fundamental, porque será la base sobre la que se apoyará todo el código que escribas en los próximos módulos.

1. Crear el proyecto BiblioTechConsola paso a paso
2. Escribir y ejecutar el primer Hola Mundo
3. Explicación línea a línea de la versión clásica
4. La variante moderna: top-level statements
5. Compilar y ejecutar con dotnet run

Abre una terminal en la carpeta donde quieras guardar tus proyectos del curso y ejecuta:

Este comando, como vimos en la lección anterior, crea una carpeta BiblioTechConsola con la estructura básica de un proyecto de consola:

Abre la carpeta BiblioTechConsola con tu editor (VS Code, Visual Studio o Rider) y localiza el archivo Program.cs. Este archivo contiene, por defecto, un pequeño programa de ejemplo generado automáticamente por la plantilla:

Esta es la versión moderna (con top-level statements) que genera dotnet new console en las versiones actuales del SDK. Vamos a modificarla para que hable de BiblioTech:

Puedes eliminar el comentario generado automáticamente (la línea que empieza por //); no es necesario para que el programa funcione, es solo información orientativa que añade la plantilla.

Guarda el archivo Program.cs con el contenido anterior y, desde la terminal, dentro de la carpeta del proyecto, ejecuta:

Deberías ver en la terminal:

¡Enhorabuena! Acabas de escribir y ejecutar tu primer programa en C#. Aunque parezca muy simple, este pequeño programa ya pone en juego varios conceptos fundamentales del lenguaje que vamos a diseccionar a continuación.

Antes de la introducción de los top-level statements (a partir de C# 9, año 2020), todo programa de consola en C# debía escribirse con una estructura más explícita. Es muy importante conocer esta forma clásica, porque:

• Es la que encontrarás en muchísimo código existente, documentación y tutoriales antiguos.
• Es, en realidad, lo que el compilador genera "por debajo" incluso cuando usamos la forma moderna y simplificada.

Así se vería nuestro mismo programa en su forma clásica y completa:

Vamos a explicar cada línea, de arriba a abajo:

Es importante fijarse en la anidación: el espacio de nombres contiene la clase, la clase contiene el método Main, y el método Main contiene la instrucción Console.WriteLine. Esta jerarquía de llaves es la estructura general de (casi) cualquier archivo .cs que escribas, y la retomaremos con más detalle en la próxima lección, "Sintaxis y Estructura Básica".

Desde C# 9, el lenguaje permite omitir todo el código "de andamiaje" (namespace, clase, método Main) cuando el programa es simple, dejando solo las instrucciones que realmente importan. A esto se le llama top-level statements (instrucciones de nivel superior). Es justo lo que generó dotnet new console al crear tu proyecto:

¿Qué ha pasado con todo lo demás? El compilador de C# sigue generando por debajo la misma estructura (namespace, class Program, static void Main) de forma automática; simplemente no tienes que escribirla tú mismo. Es exactamente el mismo programa, solo que con menos código repetitivo (boilerplate) que escribir y leer.

En este curso usaremos, por defecto, top-level statements para los ejemplos de consola sencillos (especialmente en este primer módulo), porque permiten centrarse en el concepto que se está aprendiendo sin distraerse con código repetitivo. Cuando lleguemos a la Programación Orientada a Objetos (Módulo 3), donde definiremos nuestras propias clases (Libro, Socio, Prestamo), volverá a ser habitual ver estructuras más parecidas a la forma clásica, combinadas con Main como punto de entrada.

Sí. Aunque no se declare explícitamente string[] args, el sistema pone a tu disposición una variable implícita llamada args si la necesitas:

No te preocupes si no entiendes todavía el if o la interpolación $"...": los veremos en detalle en los módulos 2 y 6 respectivamente (control de flujo y cadenas de texto). Es solo para que sepas que la variable args sigue disponible aunque no se vea el método Main explícitamente.

Ya usamos dotnet run para ejecutar nuestro programa, pero conviene entender exactamente qué ocurre "bajo el capó" cuando lo lanzamos:

1. Restauración de dependencias: dotnet comprueba si el proyecto necesita descargar paquetes externos (en nuestro caso, ninguno todavía) y los prepara si hace falta.
2. Compilación: el compilador de C# traduce el código fuente (Program.cs) a lenguaje intermedio (IL), generando un ejecutable dentro de la carpeta bin/.
3. Ejecución: el CLR carga ese ejecutable y lo ejecuta, compilando el IL a código máquina sobre la marcha (compilación JIT, mencionada en la primera lección).

Si solo quieres compilar sin ejecutar (por ejemplo, para comprobar que no hay errores sin ver la salida en pantalla), puedes usar:

Y si quieres ejecutar directamente el ejecutable ya compilado (sin pasar de nuevo por todo el proceso de compilación), puedes localizarlo dentro de bin/Debug/net8.0/ y ejecutarlo directamente desde ahí. En la práctica, durante el aprendizaje, dotnet run es la forma más cómoda y la que usaremos durante todo el curso.

Un flujo de trabajo habitual mientras aprendes es: editar Program.cs, guardar, y volver a ejecutar dotnet run. Por ejemplo, prueba a añadir una segunda línea a tu programa:

Al ejecutar dotnet run de nuevo, verás ambas líneas en la terminal, una debajo de la otra, porque WriteLine siempre añade un salto de línea al final de lo que escribe.

• Olvidar el punto y coma ; al final de una instrucción: es uno de los errores más frecuentes al empezar. El compilador mostrará un mensaje de error indicando la línea exacta donde falta.
• Guardar el archivo pero ejecutar desde la carpeta equivocada: dotnet run debe ejecutarse desde la carpeta del proyecto (donde está el archivo .csproj), no desde una carpeta superior o inferior.
• Pensar que hay que escribir siempre la forma clásica completa: no es así; para programas sencillos, los top-level statements son perfectamente válidos y son, de hecho, la forma que genera la plantilla oficial de dotnet new console.
• Confundir Console.Write con Console.WriteLine: Write escribe el texto sin saltar de línea; WriteLine sí salta de línea al final. Si dos mensajes seguidos aparecen "pegados" en la misma línea, probablemente usaste Write en lugar de WriteLine.
• Consejo: cuando el compilador muestre un error, léelo con calma: normalmente indica el archivo, la línea y una descripción bastante precisa de qué está mal (por ejemplo, "falta un punto y coma" o "no se encuentra ese nombre").

1. Crea el proyecto BiblioTechConsola siguiendo los pasos de esta lección (si no lo has hecho ya) y modifica Program.cs para que, usando top-level statements, escriba dos líneas: una con el nombre del sistema ("BiblioTechConsola") y otra con un mensaje de bienvenida a tu elección. Ejecuta el programa con dotnet run y comprueba el resultado.

2. Reescribe el programa del ejercicio anterior usando la forma clásica completa (using, namespace, class Program, static void Main), manteniendo el mismo comportamiento (las mismas dos líneas de salida). Ejecútalo y comprueba que el resultado en pantalla es idéntico al del ejercicio 1.

3. Usando la variable implícita args en la versión de top-level statements, escribe un programa que muestre "Bienvenido a BiblioTechConsola!" si no se pasa ningún argumento, o un saludo personalizado si se pasa uno. (Pista: en la mayoría de editores puedes configurar los argumentos de línea de comandos en las opciones de depuración/ejecución; si no sabes cómo hacerlo todavía, no te preocupes, céntrate en que el código compile correctamente).

1. Contenido de Program.cs:

   Console.WriteLine("BiblioTechConsola");
   Console.WriteLine("Bienvenido al sistema de gestion de la biblioteca!");
   

   Al ejecutar dotnet run, la terminal debería mostrar ambas líneas, una debajo de la otra.

2. Versión clásica equivalente:

   using System;
   
   namespace BiblioTechConsola
   {
       class Program
       {
           static void Main(string[] args)
           {
               Console.WriteLine("BiblioTechConsola");
               Console.WriteLine("Bienvenido al sistema de gestion de la biblioteca!");
           }
       }
   }
   

   El resultado en pantalla es exactamente el mismo que en el ejercicio 1, porque ambas formas se compilan, en esencia, al mismo programa.

3. Ejemplo de solución:

   if (args.Length > 0)
   {
       Console.WriteLine($"Hola, {args[0]}! Bienvenido a BiblioTechConsola.");
   }
   else
   {
       Console.WriteLine("Bienvenido a BiblioTechConsola!");
   }
   

   Si el programa se ejecuta sin argumentos, se mostrará el mensaje genérico; si se le pasa un argumento (por ejemplo, un nombre), se mostrará el saludo personalizado. No es necesario entender todavía en profundidad el if ni la interpolación $"...": los veremos con detalle más adelante en el curso.

En esta lección has creado tu primer proyecto real del curso, BiblioTechConsola, y has aprendido a distinguir entre la estructura clásica de un programa en C# (namespace, clase, método Main) y la forma moderna con top-level statements, entendiendo que ambas producen exactamente el mismo resultado. También has practicado el ciclo completo de editar y ejecutar con dotnet run.

Ahora que sabes crear y ejecutar programas, es el momento de profundizar en las reglas de sintaxis que gobiernan cualquier archivo C#: mayúsculas y minúsculas, bloques delimitados por llaves, tipos de comentarios y convenciones de nomenclatura. Eso es precisamente lo que veremos en la siguiente lección, Sintaxis y Estructura Básica.