Para escribir, compilar y ejecutar programas en C# necesitas dos cosas: el SDK de .NET (las herramientas que compilan y ejecutan tu código) y un editor o IDE donde escribir ese código cómodamente. En esta lección instalaremos y configuraremos ambos, aprenderemos los comandos básicos de la herramienta de línea de comandos dotnet, y comprobaremos que todo funciona creando y ejecutando un proyecto de prueba. Este es el paso imprescindible antes de poder empezar, en la próxima lección, con el primer programa real de BiblioTech.

1. Instalación del SDK de .NET
2. Elección de editor o IDE
3. Estructura de un proyecto de consola creado con dotnet new console
4. Comandos básicos de la CLI de dotnet
5. Verificación de que el entorno funciona

El SDK de .NET (Software Development Kit) es el conjunto de herramientas necesario para compilar y ejecutar aplicaciones .NET, incluyendo programas escritos en C#. Incluye:

• El compilador de C# (que traduce tu código fuente a lenguaje intermedio, IL).
• El runtime de .NET (el motor que ejecuta ese código, incluyendo el recolector de basura y el compilador JIT mencionados en la lección anterior).
• La CLI de dotnet, una herramienta de línea de comandos para crear, compilar, ejecutar y gestionar proyectos.

1. Visita la página oficial de descargas de .NET (dotnet.microsoft.com/download).
2. Descarga la versión LTS (Long Term Support, soporte a largo plazo) más reciente. Las versiones LTS reciben actualizaciones y soporte durante más tiempo, por lo que son la opción más segura para aprender y para proyectos reales.
3. Ejecuta el instalador correspondiente a tu sistema operativo (Windows, macOS o Linux). El proceso es el habitual: siguiente, aceptar, instalar.
4. Reinicia la terminal (o el propio ordenador, si el instalador lo indica) para que los cambios en el sistema surtan efecto.

Una vez instalado, abre una terminal (símbolo del sistema, PowerShell, terminal de Linux o macOS) y ejecuta:

Nota: aunque este comando no es código C#, en este curso mostraremos los comandos de terminal en bloques de código para que puedas distinguirlos visualmente del texto.

Si la instalación fue correcta, verás un número de versión como 8.0.100 o similar. Si en su lugar aparece un error del tipo "comando no encontrado", revisa que la instalación se completó correctamente y que la terminal se reinició.

También puedes pedir información más detallada del entorno instalado:

Este comando muestra la versión del SDK, los runtimes instalados y el sistema operativo detectado. Es muy útil cuando necesitas diagnosticar problemas de instalación.

Con el SDK instalado ya puedes compilar código C#, pero escribirlo en un editor de texto plano sería muy incómodo: sin autocompletado, sin detección de errores mientras escribes, sin ayuda para depurar. Por eso se recomienda usar un editor especializado o un IDE (Integrated Development Environment, entorno de desarrollo integrado). Estas son las tres opciones más habituales:

No hay una única opción "correcta": las tres permiten escribir y ejecutar C# perfectamente. En este curso los ejemplos funcionan igual sea cual sea tu elección; usaremos siempre la CLI de dotnet para crear y ejecutar proyectos, de forma que los pasos sean idénticos independientemente del editor.

Visual Studio Code (VS Code) es un editor de código ligero y gratuito. Por sí solo no entiende C#; para ello se instala la extensión oficial C# Dev Kit, que añade:

• Resaltado de sintaxis y autocompletado inteligente.
• Detección de errores mientras escribes (antes incluso de compilar).
• Un depurador integrado para ejecutar el código paso a paso.
• Exploración de proyectos y soluciones .NET desde el propio editor.

Para instalarla: abre VS Code, ve al panel de extensiones (icono de piezas de puzle en la barra lateral), busca "C# Dev Kit" e instálala con el botón correspondiente.

Visual Studio es el IDE histórico de Microsoft para desarrollo en C#, especialmente potente en Windows. La edición Community es gratuita para estudiantes, proyectos de código abierto y pequeños equipos. Al instalarlo, el propio instalador te permite elegir "cargas de trabajo" (workloads); para este curso bastaría con la carga de trabajo de "desarrollo de escritorio en .NET" o "desarrollo multiplataforma en .NET".

Rider es un IDE de pago (con periodo de prueba gratuito) desarrollado por JetBrains, la misma empresa detrás de IntelliJ IDEA. Es multiplataforma (Windows, macOS, Linux) y muy valorado en entornos profesionales por sus capacidades de refactorización y análisis de código.

La CLI de dotnet permite crear proyectos nuevos a partir de plantillas. La plantilla console genera un proyecto de aplicación de consola, el tipo de proyecto más sencillo y con el que trabajaremos durante buena parte de este curso. Para crear uno:

El parámetro -o (de output) indica el nombre de la carpeta donde se creará el proyecto. Al ejecutar este comando, dotnet genera la siguiente estructura de archivos:

Vamos a entender qué es cada elemento:

Al compilar el proyecto por primera vez, además aparecerá una carpeta bin/ con el programa ya compilado, listo para ejecutarse.

Un vistazo rápido al contenido del .csproj generado (no hace falta entenderlo todo todavía):

• OutputType>Exe indica que el resultado de compilar es un ejecutable (un programa que se puede lanzar), en lugar de, por ejemplo, una biblioteca.
• TargetFramework>net8.0 indica qué versión de .NET usa el proyecto para compilarse y ejecutarse.
• ImplicitUsings y Nullable son configuraciones modernas que simplifican el código; las iremos entendiendo poco a poco a lo largo del curso (los "usings implícitos" se tratan en la lección de sintaxis básica, y la nulabilidad se introduce en la lección de variables y tipos de datos).

Estos son los comandos de dotnet que usarás constantemente durante el curso:

En la práctica diaria, el comando que más usarás es dotnet run, ya que compila y ejecuta en un solo paso. Los comandos dotnet build y dotnet restore son útiles cuando quieres separar esos pasos, por ejemplo, en un proceso automatizado de integración continua.

Este flujo crea el proyecto, entra en su carpeta y lo ejecuta directamente. Como el proyecto generado por la plantilla ya incluye un "Hola Mundo" de ejemplo, verás algo como:

En la próxima lección crearemos exactamente este proyecto, lo llamaremos BiblioTechConsola, y modificaremos su contenido para trabajar con nuestro propio mensaje.

Antes de continuar con el curso, es importante confirmar que tienes todo correctamente instalado. Sigue esta lista de comprobación:

1. Ejecuta dotnet --version en una terminal y confirma que aparece un número de versión (por ejemplo, 8.0.100), sin errores.
2. Crea un proyecto de prueba con dotnet new console -o PruebaEntorno.
3. Entra en la carpeta generada (cd PruebaEntorno) y ejecútalo con dotnet run.
4. Confirma que aparece el mensaje Hello, World! (o similar) en la terminal, sin errores de compilación.
5. Abre la carpeta del proyecto con tu editor elegido (VS Code, Visual Studio o Rider) y confirma que el archivo Program.cs se abre con resaltado de sintaxis de C# y, si has instalado la extensión o carga de trabajo correspondiente, con autocompletado.
6. Una vez confirmado que todo funciona, puedes borrar la carpeta PruebaEntorno: era solo una prueba.

Si todos estos pasos funcionan sin errores, tu entorno está listo para el resto del curso.

• Olvidar reiniciar la terminal tras instalar el SDK: en muchos sistemas, la terminal necesita reiniciarse (o el propio sistema, en Windows) para reconocer el nuevo comando dotnet. Si dotnet --version no funciona nada más instalar, prueba a cerrar y volver a abrir la terminal antes de investigar más a fondo.
• Confundir dotnet build con dotnet run: build solo compila (genera el ejecutable pero no lo lanza); run compila y además ejecuta. Si esperas ver la salida del programa en pantalla, necesitas dotnet run.
• Instalar solo el runtime en lugar del SDK: existen descargas separadas para "runtime" (solo ejecutar programas ya compilados) y "SDK" (compilar y ejecutar). Para desarrollar, necesitas el SDK, no solo el runtime.
• Mezclar versiones de .NET sin necesidad: al empezar, no hace falta instalar varias versiones del SDK a la vez. Instala la versión LTS más reciente y utilízala durante todo el curso, salvo que se indique lo contrario.
• Consejo: sea cual sea el editor elegido, dedica unos minutos a familiarizarte con su explorador de archivos y su terminal integrada; los usarás constantemente durante el curso.

1. Instala (si no lo tienes ya) el SDK de .NET siguiendo los pasos de esta lección, y ejecuta dotnet --version y dotnet --info. Anota qué versión del SDK y qué sistema operativo te informa el segundo comando.

2. Crea un proyecto de consola de prueba llamado PruebaEntorno con dotnet new console. Sin abrir todavía ningún editor, examina con el explorador de archivos de tu sistema (o con el comando ls/dir) qué archivos y carpetas se han generado, y relaciónalos con la tabla de esta lección.

3. Ejecuta el proyecto PruebaEntorno con dotnet run. Después, abre el archivo Program.cs con el editor que hayas elegido y cambia el texto "Hello, World!" por un mensaje distinto, por ejemplo "Entorno de BiblioTech listo!". Vuelve a ejecutar dotnet run y comprueba que el nuevo mensaje aparece en pantalla.

1. La salida variará según tu equipo, pero un ejemplo típico sería: dotnet --version → 8.0.100; dotnet --info mostrando el SDK instalado, el sistema operativo (por ejemplo, Linux o Windows), y la arquitectura (x64, arm64, etc.). Si el comando falla, revisa la instalación siguiendo de nuevo los pasos indicados en esta lección.

2. Al crear el proyecto se generan, como mínimo, PruebaEntorno.csproj (archivo de proyecto) y Program.cs (código fuente), y tras la primera compilación también aparecerá una carpeta obj/ (y, al ejecutar, bin/). Esto coincide con la estructura descrita en la sección "Estructura de un proyecto de consola".

3. Tras cambiar la línea en Program.cs (algo como Console.WriteLine("Entorno de BiblioTech listo!");) y volver a ejecutar dotnet run, la terminal debería mostrar: Entorno de BiblioTech listo!. Esto confirma que el editor, el SDK y la CLI de dotnet funcionan correctamente juntos.

En esta lección has preparado tu entorno de desarrollo completo: el SDK de .NET, un editor o IDE de tu elección, y los comandos básicos de la CLI de dotnet (new, build, run, restore). También has aprendido la estructura mínima de un proyecto de consola y has comprobado, paso a paso, que todo funciona correctamente.

Con el entorno ya listo, en la siguiente lección, Programa Hola Mundo, crearemos nuestro primer proyecto real del curso —BiblioTechConsola— y analizaremos línea a línea cada parte del código, incluyendo la forma clásica y la forma moderna (top-level statements) de escribirlo.