2. Configuración del entorno de desarrollo
En 2008, se instalaba Visual C# 2008 Express, que incluía el framework .NET 3.5, el SGBD SQL Compact Server y la documentación de MSDN, y luego se creaban los proyectos mediante asistentes gráficos. Hoy en día, el entorno de desarrollo se compone de dos elementos independientes:
- el SDK de .NET (“Software Development Kit”): el compilador, la plataforma de ejecución, las bibliotecas y el comando [dotnet], que permite hacerlo todo desde la línea de comandos (crear, compilar, ejecutar, probar y publicar un programa);
- un editor o un IDE (entorno de desarrollo integrado): [VS Code] con la extensión [C# Dev Kit], o [Visual Studio 2026], o [JetBrains Rider]. El editor se apoya en el SDK.
Este documento utiliza el comando [dotnet] para todas las operaciones: funciona de la misma manera en Windows, Linux y macOS, sea cual sea el editor elegido.
2.1. SDK de .NET 10
2.1.1. Instalación
El SDK de .NET 10 se puede descargar desde https://dotnet.microsoft.com/download/dotnet/10.0. En Windows, también se puede instalar desde un terminal (PowerShell o símbolo del sistema) con el administrador de paquetes [winget]:
Debe seleccionar el SDK (que contiene todo) y no solo el “runtime” (que únicamente permite ejecutar programas ya compilados). En Linux, el SDK está disponible en los repositorios de las principales distribuciones (por ejemplo, [sudo apt install dotnet-sdk-10.0] en Ubuntu; según la versión de la distribución, quizá deba agregar antes el repositorio indicado en la documentación de instalación de Microsoft).
Tras la instalación, abra un nuevo terminal para comprobar que el comando [dotnet] está disponible y muestra la versión del SDK:
El comando [dotnet --list-sdks] enumera las versiones del SDK instaladas (pueden coexistir varias versiones):
La versión exacta (en este caso, [10.0.112]) depende de la fecha de instalación: Microsoft publica una actualización correctiva cada mes. Todas las versiones del SDK 10.0.x son adecuadas para este documento. El comando [dotnet --info] proporciona información más detallada (sistema operativo, ubicación del SDK, versiones de las plataformas de ejecución instaladas).
2.1.2. El comando dotnet
El comando [dotnet] incluye numerosos subcomandos. Estos son los que utilizaremos:
Comando | Función |
[dotnet run file.cs] | compila y ejecuta una aplicación de un solo archivo |
[dotnet new console -n Name] | crea un proyecto de consola en la carpeta [Name] (otras plantillas: [classlib], [mstest], [web]…) |
[dotnet build] | compila el proyecto de la carpeta actual |
[dotnet run] | compila (si es necesario) y ejecuta el proyecto de la carpeta actual |
[dotnet test] | ejecuta las pruebas unitarias (Capítulo 6) |
[dotnet new sln] | crea una solución (un archivo que agrupa varios proyectos) |
[dotnet sln add Project] | agrega un proyecto a la solución |
[dotnet add package Name] | agrega una biblioteca NuGet al proyecto (Capítulos 10 y 11) |
[dotnet add reference ../Other] | agrega una referencia a otro proyecto (Capítulo 6) |
[dotnet publish] | prepara el programa para su despliegue |
Las bibliotecas que no forman parte de la plataforma se distribuyen como paquetes NuGet, descargados desde https://www.nuget.org y almacenados en la computadora, en la carpeta [%USERPROFILE%\.nuget\packages]. En 2008, se copiaban los archivos DLL de las bibliotecas (Spring.NET, NUnit y el conector de MySQL) en una carpeta [lib] dentro del proyecto; hoy, el proyecto declara los paquetes que necesita y el comando [dotnet] los descarga.
2.2. El editor
2.2.1. VS Code
VS Code es un editor gratuito y multiplataforma. Para programar en C#, se agrega la extensión C# Dev Kit de Microsoft (vaya al menú “Extensiones” y busque “C# Dev Kit”), que también instala la extensión C#. Esto proporciona:
- resaltado de sintaxis, autocompletado de código y ayuda contextual;
- detección de errores mientras se escribe;
- navegación por el código (F12: Ir a la definición);
- un Explorador de soluciones (vista “Solution Explorer”);
- ejecución y depuración (F5);
- ejecución de pruebas unitarias (vista “Testing”).
En VS Code, abra la carpeta que contiene los programas (“File / Open Folder”), por ejemplo, la carpeta [csharp-oct-2026] con los ejemplos de este documento. El terminal integrado (“Terminal / New Terminal”) permite escribir comandos [dotnet] sin salir del editor.
2.2.2. Visual Studio 2026
En Windows, quizá prefiera usar Visual Studio 2026, el sucesor de Visual Studio 2008, utilizado en el curso original. Su edición Community es gratuita para particulares, instituciones educativas y proyectos de código abierto. Instálelo desde https://visualstudio.microsoft.com seleccionando la carga de trabajo “Desarrollo de escritorio de .NET” (y “Desarrollo web y ASP.NET” para el Capítulo 13). Visual Studio abre directamente las soluciones [.slnx] y los proyectos [.csproj] de los ejemplos (“File / Open / Project/Solution”) y los ejecuta con [Ctrl-F5] (sin depuración) o [F5] (con depuración), igual que en 2008.
Una tercera opción es JetBrains Rider, que es gratuito para uso no comercial.
En el resto de este documento, los pasos se describen con el comando [dotnet], que produce los mismos resultados sea cual sea el editor.
2.3. Un primer programa: una aplicación de un solo archivo
2.3.1. El programa
A partir de .NET 10, un programa C# puede ser un único archivo [.cs], sin archivo de proyecto. Esto se denomina “aplicación basada en archivos” (“file-based app”). Creemos el siguiente archivo [hello.cs]:
y ejecutémoslo:
Comentarios:
- línea 1: un comentario. Todo lo que sigue a [//] hasta el final de la línea es ignorado por el compilador;
- línea 2: la única instrucción del programa: imprime una línea de texto en la pantalla. El programa no tiene ni una clase ni un método llamado [Main], a diferencia de su equivalente de 2008; veremos en el Capítulo 3 que el propio compilador los genera;
- El comando [dotnet run hello.cs] compila el programa y luego lo ejecuta. La primera ejecución tarda unos segundos; las siguientes son casi inmediatas mientras el archivo no cambie, ya que el resultado de la compilación se almacena en una caché.
Las aplicaciones de un solo archivo son adecuadas para programas pequeños y las usaremos en la mayoría de los ejemplos. Algunas directivas, colocadas al principio del archivo, permiten crearlas sin un archivo de proyecto:
- la directiva [#:package] agrega una biblioteca NuGet (Capítulo 10);
- la directiva [#:property] establece una propiedad de compilación (Capítulo 5);
- la directiva [#:sdk] selecciona un SDK distinto, como el de las aplicaciones web (Capítulo 12).
En Windows, si los archivos [.cs] se guardan como UTF-8 (que es el valor predeterminado en VS Code), los caracteres acentuados se muestran correctamente en el terminal.
2.3.2. Conversión de una aplicación de un solo archivo en un proyecto
Cuando una aplicación de un solo archivo crece (varios archivos, pruebas, referencias a otros proyectos), se convierte en un proyecto:
El comando crea una carpeta llamada [hello] que contiene una copia del programa y un archivo de proyecto llamado [hello.csproj]:
El archivo de proyecto hereda las propiedades predeterminadas de las aplicaciones de un solo archivo (por ejemplo, [PublishAot], que prepara la compilación anticipada a código nativo). Puede eliminar las que no necesite. Ahora veremos los proyectos con más detalle.
2.4. Un proyecto de consola
2.4.1. Creación del proyecto
Un proyecto es una carpeta que contiene un archivo de proyecto ([.csproj]) y archivos de código fuente. Se crea con el comando [dotnet new] seguido del nombre de una plantilla (en este caso, [console], una aplicación de consola):
El comando creó una carpeta llamada [FirstProgram] que contiene dos archivos. El archivo de proyecto [FirstProgram.csproj] es el siguiente:
- Línea 1: el proyecto utiliza el SDK [Microsoft.NET.Sdk], el de las aplicaciones de consola y las bibliotecas;
- línea 4: el proyecto produce un ejecutable ([Exe]) y no una biblioteca;
- línea 5: la plataforma de destino es .NET 10 ([net10.0]);
- línea 6: los espacios de nombres más comunes ([System], [System.IO], [System.Linq]…) se importan automáticamente en todos los archivos (Capítulo 3);
- línea 7: el compilador verifica el uso de referencias nulas y emite advertencias sobre posibles errores (Capítulos 3 y 4).
El archivo de 2008 describía, en unas cien líneas, cada archivo fuente del proyecto, las referencias a bibliotecas y las configuraciones Debug/Release. El archivo de proyecto actual solo contiene los ajustes que difieren de los valores predeterminados: todos los archivos [.cs] de la carpeta forman parte del proyecto.
Reemplazamos el contenido del archivo [Program.cs] generado por el siguiente:
2.4.2. Compilación y ejecución
El comando [dotnet build], escrito en la carpeta del proyecto, compila el proyecto:
- Línea 2: el comando comienza por restaurar el proyecto, es decir, descargar los paquetes NuGet de los que depende (aquí no hay ninguno);
- Línea 4: el resultado de la compilación es una DLL, el archivo [FirstProgram.dll] colocado en la carpeta [bin/Debug/net10.0] del proyecto. En Windows, la ruta que se muestra es una ruta de Windows ([bin\Debug\net10.0\FirstProgram.dll]).
La carpeta [bin/Debug/net10.0] contiene entonces los siguientes archivos:
- [FirstProgram.dll] contiene el código compilado (en código intermedio IL);
- [FirstProgram] (en Windows, [FirstProgram.exe]) es un pequeño lanzador que inicia la plataforma .NET y le hace ejecutar la DLL;
- [FirstProgram.pdb] contiene la información que utiliza el depurador;
- los dos archivos [.json] describen las dependencias del programa y la versión de .NET necesaria para ejecutarlo.
Se puede ejecutar el lanzador directamente:
Sin embargo, lo más habitual es usar el comando [dotnet run], que compila el proyecto si es necesario y luego lo ejecuta:
Como en 2008, existen dos configuraciones de compilación: Debug (predeterminada, con información de depuración) y Release (optimizada, para producción), que se seleccionan con la opción [-c Release]: [dotnet build -c Release] genera el programa en la carpeta [bin/Release/net10.0]. La carpeta [obj] contiene archivos intermedios de la compilación. Las carpetas [bin] y [obj] se pueden eliminar sin riesgo: se vuelven a crear en la siguiente compilación.
2.5. Una solución con varios proyectos
2.5.1. Creación de la solución
Una solución agrupa varios proyectos. Permite abrirlos juntos en el editor y compilarlos juntos. Creemos una solución en la carpeta que contiene el proyecto [FirstProgram]:
y agreguemos el proyecto a ella:
Agreguemos un segundo proyecto, [TwoHands], cuyo contenido veremos más adelante:
El comando [dotnet sln list] enumera los proyectos de la solución:
El archivo de solución [02-installation.slnx] es el siguiente:
Se trata de un archivo XML muy sencillo. Desde .NET 10, este es el formato predeterminado de las soluciones ([.slnx]). El antiguo formato [.sln], usado en Visual Studio 2008, era mucho más extenso; todavía se encuentra en proyectos existentes y el comando [dotnet new sln --format sln] aún permite crearlo.
En la carpeta de la solución, el comando [dotnet build] compila todos los proyectos de la solución. Para ejecutar un proyecto específico, vaya a su carpeta y escriba [dotnet run], o utilice la opción [--project]: [dotnet run --project FirstProgram].
2.5.2. Un proyecto con varios métodos Main
El curso de 2008 demostraba que un proyecto puede contener varias clases, cada una con un método estático llamado [Main], y que hay que indicar cuál se ejecuta. Esto sigue siendo posible. El proyecto [TwoHands] contiene dos clases. La clase [P1]:
y la clase [P2]:
Si se compila el proyecto sin tomar más precauciones, se obtiene un error:
El compilador no sabe cuál de los métodos [Main] es el punto de entrada del programa. Lo indicamos en el archivo de proyecto mediante la propiedad [StartupObject]:
- Línea 9: el método [Main] que se ejecutó pertenece a la clase [TwoHands.P2] (el nombre completo de la clase, incluido el espacio de nombres).
Resultados:
Con las instrucciones de nivel superior (Capítulo 3), la cuestión ya no se plantea: un único archivo del proyecto puede contenerlas, y ese archivo sirve de punto de entrada.
2.6. Ejemplos de este documento
Para ejecutar los ejemplos de este documento:
- descargue la carpeta [csharp-oct-2026] (enlace al principio del documento);
- ábrala en VS Code (“File / Open Folder”) o, para un capítulo específico, abra en Visual Studio la solución del capítulo ([.slnx]) ;
- en un terminal situado en la carpeta de un capítulo, ejecute una aplicación de un solo archivo con [dotnet run name.cs], o un proyecto con [dotnet run] en la carpeta del proyecto.
Los Capítulos 10 y 11 utilizan una base de datos MySQL; la instalación de MySQL con [Laragon] se describe en el apéndice.