Skip to content

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]:

winget install Microsoft.DotNet.SDK.10

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:

> dotnet --version
10.0.112

El comando [dotnet --list-sdks] enumera las versiones del SDK instaladas (pueden coexistir varias versiones):

> dotnet --list-sdks
10.0.112 [C:\Program Files\dotnet\sdk]

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]:

// primer programa en C#: una aplicación de un solo archivo
Console.WriteLine("1st try with C# 14 and .NET 10");

y ejecutémoslo:

> dotnet run hello.cs
1st try with C# 14 and .NET 10

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:

1
2
3
#:package MySqlConnector@2.4.0
#:property PublishAot=false
#:sdk Microsoft.NET.Sdk.Web
  • 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:

> dotnet project convert hello.cs -o hello

El comando crea una carpeta llamada [hello] que contiene una copia del programa y un archivo de proyecto llamado [hello.csproj]:

1
2
3
4
> dir /s /b (list of files)
hello.cs
hello/hello.cs
hello/hello.csproj
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PublishAot>true</PublishAot>
    <PackAsTool>true</PackAsTool>
    <UserSecretsId>hello-7b9b5da29436665281cfbf4b23ebf4fed6297358227418ac7d456d2e18d162bf</UserSecretsId>
  </PropertyGroup>

</Project>

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):

1
2
3
4
5
6
7
8
> dotnet new console -n FirstProgram
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring csharp-oct-2026/02-installation/FirstProgram/FirstProgram.csproj:
  Determining projects to restore...
  Restored csharp-oct-2026/02-installation/FirstProgram/FirstProgram.csproj (in 127 ms).
Restore succeeded.

El comando creó una carpeta llamada [FirstProgram] que contiene dos archivos. El archivo de proyecto [FirstProgram.csproj] es el siguiente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>
  • 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:

// el programa principal del proyecto [FirstProgram]
Console.WriteLine("1st try with a C# 14 / .NET 10 project");

2.4.2. Compilación y ejecución

El comando [dotnet build], escrito en la carpeta del proyecto, compila el proyecto:

> dotnet build
  Determining projects to restore...
  All projects are up-to-date for restore.
  FirstProgram -> csharp-oct-2026/02-installation/FirstProgram/bin/Debug/net10.0/FirstProgram.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:01.56
  • 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:

1
2
3
4
5
6
> dir bin\Debug\net10.0 (list of files)
FirstProgram
FirstProgram.deps.json
FirstProgram.dll
FirstProgram.pdb
FirstProgram.runtimeconfig.json
  • [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:

> FirstProgram
1st try with a C# 14 / .NET 10 project

Sin embargo, lo más habitual es usar el comando [dotnet run], que compila el proyecto si es necesario y luego lo ejecuta:

> dotnet run
1st try with a C# 14 / .NET 10 project

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]:

> dotnet new sln -n 02-installation
The template "Solution File" was created successfully.

y agreguemos el proyecto a ella:

> dotnet sln add FirstProgram
Project `FirstProgram/FirstProgram.csproj` added to the solution.

Agreguemos un segundo proyecto, [TwoHands], cuyo contenido veremos más adelante:

> dotnet sln add TwoHands
Project `TwoHands/TwoHands.csproj` added to the solution.

El comando [dotnet sln list] enumera los proyectos de la solución:

1
2
3
4
5
> dotnet sln list
Project(s)
----------
FirstProgram/FirstProgram.csproj
TwoHands/TwoHands.csproj

El archivo de solución [02-installation.slnx] es el siguiente:

1
2
3
4
<Solution>
  <Project Path="TwoHands/TwoHands.csproj" />
  <Project Path="FirstProgram/FirstProgram.csproj" />
</Solution>

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]:

1
2
3
4
5
6
7
8
9
namespace TwoHands;

class P1
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main of class P1");
    }
}

y la clase [P2]:

1
2
3
4
5
6
7
8
9
namespace TwoHands;

class P2
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main of class P2");
    }
}

Si se compila el proyecto sin tomar más precauciones, se obtiene un error:

> dotnet build
...\TwoHands\P1.cs(5,17): error CS0017: Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point. 

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]:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <!-- la clase cuyo método Main se ejecuta -->
    <StartupObject>TwoHands.P2</StartupObject>
  </PropertyGroup>

</Project>
  • 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:

> dotnet run
Main of class P2

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.