Ir al contenido
learn
Menú global

1. Instalar .NET y ejecutar tu primer programa

Código: examples/l01_hello.cs, examples/l01_statements.cs, los fragmentos rechazados de compile_fail/ y el proyecto l01-project/Hello.

Qué es un programa

Sección titulada «Qué es un programa»

Un programa es una lista de instrucciones para el ordenador, escrita en un lenguaje que las personas pueden leer. El ordenador no puede ejecutar ese texto directamente: una herramienta llamada compilador primero lo revisa y lo traduce.

Con C#, la traducción tiene dos pasos:

flowchart LR
    A["hello.cs<br/>tu código C#"] -->|"el compilador de C#<br/>comprueba y traduce"| B["hello.dll<br/>lenguaje intermedio"]
    B -->|"el runtime de .NET<br/>traduce a código máquina durante la ejecución"| C["Salida<br/>Hello, world!"]
  1. El compilador de C# lee tu archivo .cs. Si algo está mal, se detiene e imprime un error. Si no, escribe un archivo .dll en un lenguaje intermedio (IL), el mismo en todos los ordenadores.
  2. El runtime de .NET carga el .dll y lo convierte en instrucciones para tu procesador a medida que el programa se ejecuta.

Instalas ambos a la vez con el SDK de .NET (Software Development Kit, kit de desarrollo de software). También contiene el comando dotnet, que usarás para todo: crear, compilar, ejecutar y probar programas. La introducción a .NET describe las piezas con más detalle.

Este curso usa .NET 10, una versión con soporte a largo plazo, y C# 14, la versión del lenguaje que la acompaña.

Abrir una terminal

Sección titulada «Abrir una terminal»

Una terminal es una ventana donde escribes comandos. Todos los comandos de este curso se escriben ahí y se ejecutan con Enter.

Pulsa Win, escribe Terminal y abre Terminal. Arranca PowerShell. En Windows 10, si Terminal no está instalado, abre Windows PowerShell en su lugar.

Instalar el SDK de .NET

Sección titulada «Instalar el SDK de .NET»

Windows incluye el gestor de paquetes WinGet. En la terminal:

Ventana de terminal
winget install Microsoft.DotNet.SDK.10

Cierra la terminal y abre una nueva, para que encuentre el comando dotnet. También puedes descargar el instalador desde la página de descarga de .NET. La guía de instalación para Windows enumera las demás formas.

Después comprueba que el SDK responde:

> dotnet --version
10.0.112

Cualquier versión que empiece por 10.0 sirve. Si la terminal dice que dotnet no se reconoce, o command not found, abre una terminal nueva; si sigue fallando, vuelve a seguir la guía de instalación de tu sistema operativo.

Tu primer programa

Sección titulada «Tu primer programa»

Crea una carpeta para el curso y, dentro, un archivo llamado hello.cs con cualquier editor de texto (Bloc de notas, TextEdit, nano, o los editores descritos al final de esta lección). Escribe en él esta única línea:

Console.WriteLine("Hello, world!");

Guarda el archivo, ve a su carpeta en la terminal con cd y ejecútalo:

> dotnet run hello.cs
Hello, world!

dotnet run compiló el archivo y luego lo ejecutó. Ejecutar de nuevo el mismo archivo es más rápido: el SDK guarda el programa compilado y solo vuelve a compilar cuando el archivo cambia. Un único archivo .cs ejecutado así es una aplicación basada en archivos (file-based app), novedad de .NET 10. La mayoría de los ejemplos de este curso son aplicaciones basadas en archivos.

Leamos la línea pieza por pieza:

Pieza Significado
Console la consola: la ventana de texto en la que escribe tu programa
. «dentro de»: WriteLine pertenece a Console
WriteLine un método, un trabajo con nombre: escribir una línea de texto
( … ) lo que le das al método para trabajar, su argumento
"Hello, world!" una cadena (string): texto, entre comillas dobles
; el final de la instrucción, como el punto al final de una frase

C# distingue mayúsculas y minúsculas: Console y console son dos nombres distintos, y solo existe el primero. Las comillas no se imprimen: solo le indican al compilador dónde empieza y dónde termina el texto.

Varias instrucciones

Sección titulada «Varias instrucciones»

Un programa ejecuta sus instrucciones una tras otra, de arriba abajo:

// Un comentario empieza con dos barras: el compilador lo ignora
Console.WriteLine("Guitar Alchemist tunes a guitar like this:");
Console.Write("E2 A2 D3 ");   // Write no pasa a la línea siguiente
Console.Write("G3 B3 E4");
Console.WriteLine();          // un WriteLine vacío termina la línea
Console.WriteLine("Six strings, from the lowest to the highest.");


/* Un comentario también puede
   ocupar varias líneas */
Console.WriteLine(6 * 12);    // el ordenador calcula y luego imprime el resultado
> dotnet run examples/l01_statements.cs
Guitar Alchemist tunes a guitar like this:
E2 A2 D3 G3 B3 E4
Six strings, from the lowest to the highest.
72
  • Console.Write escribe texto y se queda en la misma línea; Console.WriteLine escribe texto y pasa a la línea siguiente.
  • Un comentario es una nota para las personas. // convierte en comentario el resto de la línea; /* y */ rodean un comentario que puede ocupar varias líneas.
  • 6 * 12 no lleva comillas: no es texto, es un cálculo. El programa calcula 72 e imprime el número. Con comillas, "6 * 12" imprimiría los caracteres 6 * 12.

La afinación viene de Guitar Alchemist, una aplicación C# sobre música: su afinación por defecto se escribe E2 A2 D3 G3 B3 E4 en Tuning.cs. Una letra es una nota (en notación inglesa: E es mi, A es la), y el número es su octava.

En una aplicación basada en archivos, las instrucciones al principio del archivo son el punto de partida del programa. La documentación de C# las llama instrucciones de nivel superior.

Leer un error del compilador

Sección titulada «Leer un error del compilador»

Todo el mundo se equivoca al escribir código. El compilador encuentra los errores antes de que el programa se ejecute. Aquí falta el punto y coma al final de la primera línea:

Console.WriteLine("Hello, world!")
Console.WriteLine("Goodbye!");
> dotnet run l01_missing_semicolon.cs
C:\Users\spare\source\repos\learn\code\csharp-beginner\compile_fail\l01_missing_semicolon.cs(1,35): error CS1002: ; expected


The build failed. Fix the build errors and run again.

La línea de error tiene cinco partes:

Parte Aquí Significado
archivo C:\…\l01_missing_semicolon.cs qué archivo
posición (1,35) línea 1, columna 35: el carácter donde el compilador notó el problema
tipo error el programa no se puede compilar; un warning (advertencia) dejaría que se ejecutara
código CS1002 el número del error: búscalo en la lista de mensajes del compilador
mensaje ; expected lo que el compilador esperaba encontrar («se esperaba ;»)

La columna 35 está justo después del paréntesis de cierre, donde debería ir el ;. No se ejecutó nada: ni siquiera la segunda línea. La ruta completa del archivo depende de tu carpeta, así que el resto del curso muestra solo el nombre del archivo.

Otros dos errores que comete todo principiante. Un console en minúscula:

console.WriteLine("Hello, world!");
l01_lowercase.cs(1,1): error CS0103: The name 'console' does not exist in the current context

Unas comillas de cierre que faltan:

Console.WriteLine("Hello, world!);
l01_missing_quote.cs(1,19): error CS1010: Newline in constant
l01_missing_quote.cs(1,35): error CS1026: ) expected
l01_missing_quote.cs(1,35): error CS1002: ; expected

Un error, tres mensajes. Sin las comillas de cierre, la cadena llega hasta el final de la línea (CS1010, «newline in constant», salto de línea en una constante) y se traga el ) y el ;, que ahora también faltan. Corrige primero el primer error y vuelve a ejecutar: los siguientes a menudo desaparecen con él.

Ejecutar un archivo como script

Sección titulada «Ejecutar un archivo como script»

En Linux y macOS, una aplicación basada en archivos puede ejecutarse como cualquier otro comando. Su primera línea, que empieza con una almohadilla y un signo de exclamación, #! (un shebang), le dice al sistema que la ejecute con dotnet:

#!/usr/bin/env -S dotnet --
Console.WriteLine("Hello from a script!");

Windows no lee las líneas shebang. dotnet run l01_shebang.cs funciona igualmente: el compilador ignora la primera línea.

Un proyecto

Sección titulada «Un proyecto»

Un único archivo es perfecto para aprender y para herramientas pequeñas. Los programas más grandes tienen muchos archivos, y un proyecto los agrupa. dotnet new console crea uno:

> dotnet new console -o HelloApp
The template "Console App" was created successfully.


Processing post-creation actions...
Restoring C:\Users\spare\…\HelloApp\HelloApp.csproj:
  Determining projects to restore...
  Restored C:\Users\spare\…\HelloApp\HelloApp.csproj (in 66 ms).
Restore succeeded.

-o HelloApp da nombre a la carpeta de salida, y al proyecto con ella. La carpeta contiene dos archivos, y una carpeta obj que usa la compilación:

HelloApp/
├── HelloApp.csproj   ← el archivo de proyecto: cómo compilar el programa
├── Program.cs        ← el código
└── obj/
<Project Sdk="Microsoft.NET.Sdk">


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


</Project>
  • OutputType Exe: el proyecto genera un programa que puedes ejecutar, no una biblioteca para otros programas.
  • TargetFramework net10.0: el programa se ejecuta en .NET 10.
  • ImplicitUsings y Nullable activan dos comodidades a las que vuelve la lección 4. Las aplicaciones basadas en archivos también las activan.

Program.cs contiene el mismo tipo de código que hello.cs:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

Dentro de la carpeta del proyecto, dotnet run no necesita nombre de archivo: encuentra el archivo .csproj.

> cd HelloApp
> dotnet run
Hello, World!

dotnet build solo compila, y escribe el programa en bin/Debug/net10.0/: HelloApp.dll, y en Windows un HelloApp.exe que lo arranca.

Cuando una aplicación basada en archivos crece, dotnet project convert hello.cs la convierte en proyecto: crea una carpeta con un archivo .csproj y una copia del código.

Quieres Aplicación basada en archivos Proyecto
Crear cualquier editor: un archivo .cs dotnet new console -o Name
Ejecutar dotnet run hello.cs dotnet run, en la carpeta
Solo compilar dotnet build hello.cs dotnet build
Varios archivos de código un archivo; el SDK 10.0.300 y posteriores añaden #:include sí
Adecuado para aprender, scripts, herramientas pequeñas aplicaciones, bibliotecas, pruebas

Elegir un editor

Sección titulada «Elegir un editor»

Cualquier editor de texto sirve, pero un editor de código colorea el código, completa los nombres mientras escribes, subraya los errores antes de ejecutar y te deja ejecutar el programa paso a paso con un depurador (lección 3). Hay tres editores pensados para C#:

Editor Funciona en Precio Notas
Visual Studio Code con la extensión C# Dev Kit Windows, Linux, macOS gratuito; el C# Dev Kit es gratuito para particulares ligero, la opción más habitual para aprender
Visual Studio Community Windows gratuito para particulares y estudiantes un entorno grande y completo
JetBrains Rider Windows, Linux, macOS gratuito para uso no comercial un entorno completo de JetBrains

Rider y VS Code están instalados en el ordenador en el que se escribió este curso. Las licencias cambian con el tiempo: lee las condiciones de cada editor cuando lo instales (por verificar).

Puntos clave

Sección titulada «Puntos clave»
  • El SDK de .NET contiene el compilador de C#, el runtime de .NET y el comando dotnet; dotnet --version comprueba que está instalado.
  • dotnet run hello.cs compila y ejecuta un archivo; en la carpeta de un proyecto, dotnet run compila y ejecuta el proyecto.
  • Una instrucción termina con ;, las cadenas van entre comillas dobles y C# distingue mayúsculas y minúsculas.
  • Un error del compilador da el archivo, la línea y la columna, un código como CS1002 y un mensaje: corrige primero el primer error.
  • dotnet new console crea un proyecto: un archivo .csproj que dice cómo compilar, y Program.cs.

Ejercicios

Sección titulada «Ejercicios»
  1. Escribe una aplicación basada en archivos chord.cs que imprima el nombre de un acorde, las seis cuerdas y los trastes que hay que pisar para un acorde de do mayor, C en notación inglesa (x 3 2 0 1 0: x significa «no toques esta cuerda»). En una última línea, imprime la suma de los tres números de traste, calculada por el programa.
Solución

exercises/l01_ex_chord.cs:

// Un acorde de do mayor (x32010), dibujado con un WriteLine por línea
Console.WriteLine("C major");
Console.WriteLine("E A D G B E");
Console.WriteLine("x 3 2 0 1 0");
Console.WriteLine("Frets played: " + (3 + 2 + 1));
C major
E A D G B E
x 3 2 0 1 0
Frets played: 6

"Frets played: " + (3 + 2 + 1) calcula primero los paréntesis, 6, y luego + pega el texto y el número. Sin los paréntesis, el resultado sería Frets played: 321: de izquierda a derecha, texto más 3 es el texto Frets played: 3, y así sucesivamente. La lección 2 explica por qué.

  1. Este programa tiene tres errores. Ejecútalo, corrige lo que indica el compilador y vuelve a ejecutarlo hasta que funcione. ¿Cuántas veces tuviste que ejecutarlo?
Console.Writeline("Strings of a guitar:");
Console.WriteLine("E A D G B E")
Console.WriteLine("That makes " + 6 + " strings);
Solución

La primera ejecución señala el ; que falta en la línea 2 y las comillas que faltan en la línea 3:

l01_ex_broken.cs(2,33): error CS1002: ; expected
l01_ex_broken.cs(3,39): error CS1010: Newline in constant
l01_ex_broken.cs(3,50): error CS1026: ) expected
l01_ex_broken.cs(3,50): error CS1002: ; expected

No dice nada de Writeline en la línea 1. El compilador trabaja por etapas: primero comprueba que el texto tiene la forma de C# (la sintaxis) y, solo si la tiene, si los nombres existen. Tras corregir las líneas 2 y 3, la segunda ejecución encuentra el tercer error:

l01_ex_broken_step2.cs(1,9): error CS0117: 'Console' does not contain a definition for 'Writeline'

El método es WriteLine, con L mayúscula. La tercera ejecución funciona (exercises/l01_ex_fixed.cs):

Strings of a guitar:
E A D G B E
That makes 6 strings
  1. Crea un proyecto con dotnet new console -o Tuning, sustituye el código de Program.cs por el programa de Varias instrucciones y ejecútalo. Después, todavía en la carpeta, ejecuta dotnet build y busca el archivo .dll. ¿Cómo se llama?
Solución

dotnet run imprime las mismas cuatro líneas que dotnet run l01_statements.cs. dotnet build escribe bin/Debug/net10.0/Tuning.dll: el programa lleva el nombre del proyecto, no el de Program.cs. dotnet bin/Debug/net10.0/Tuning.dll lo ejecuta sin volver a compilar.

Fuentes

Sección titulada «Fuentes»