# C# y .NET desde cero para principiantes

**Categoría:** Programación · **Nivel:** Inicial · **Lectura:** 19 min
**Publicada:** 2026-07-29 · **Actualizada:** 2026-07-29 · **Autoría:** Underc0de
**Versión HTML (canónica):** https://underc0de.org/guias/programacion/csharp-y-net-desde-cero/

## Respuesta rápida

**C#** es el lenguaje de programación: la sintaxis, las clases y la lógica que escribís. **.NET** es la plataforma que lo ejecuta: un runtime (el **CLR**) más una enorme biblioteca de clases ya resueltas (la **BCL**). Confundir uno con el otro es el error más común al empezar. El **SDK** (kit de desarrollo) es lo que instalás en tu máquina, e incluye la **CLI** (interfaz de línea de comandos) de `dotnet`, con la que creás, compilás y ejecutás proyectos. Esta guía va de instalar el SDK a escribir y entender tu primer programa en C#, incluida la novedad de .NET 10 que permite correr un archivo `.cs` suelto sin crear un proyecto.

## C# es el lenguaje, .NET es la plataforma

La confusión más habitual de quien empieza con C# es tratar a **C#** y a **.NET** como si fueran sinónimos, o directamente el mismo producto con dos nombres. No lo son, y entender la diferencia desde el primer día evita malentendidos más adelante, sobre todo al leer documentación o tutoriales de distintas épocas.

**C#** (se pronuncia «C sharp») es un **lenguaje de programación** de propósito general, orientado a objetos y de **tipado estático** —es decir, el tipo de cada dato se fija y se verifica antes de ejecutar el programa—, creado por Microsoft. Es lo que vos escribís: la sintaxis, las clases, las variables, las condiciones, los bucles. **.NET**, en cambio, es la **plataforma** que ejecuta ese código: un entorno formado por un **runtime** (el programa que corre por debajo mientras tu aplicación funciona) llamado **CLR** (*Common Language Runtime*), y una gran **biblioteca de clases base** o **BCL** (*Base Class Library*), con funcionalidad ya resuelta para trabajar con archivos, colecciones, texto, fechas o conexiones de red, entre muchísimas otras cosas.

| Aspecto | C# | .NET |
|---|---|---|
| Qué es | Un lenguaje de programación | Una plataforma de ejecución y bibliotecas |
| Qué contiene | Sintaxis, tipos, clases, reglas gramaticales | Runtime (CLR), biblioteca de clases (BCL) y herramientas (SDK) |
| Analogía | La receta: las instrucciones que escribís | La cocina: lo que efectivamente las ejecuta |
| ¿Depende del otro? | Necesita una plataforma que lo ejecute | No depende de un único lenguaje: también corre F# o Visual Basic .NET |

> **Por qué importa la distinción**
>
> Cuando instalás «.NET» estás instalando la plataforma completa: el runtime, las bibliotecas y, si instalás el SDK, también las herramientas para compilar código C# (o F#, o VB.NET). El lenguaje que elijas escribir es una decisión aparte de la plataforma sobre la que corre.

## .NET Framework y .NET moderno: qué cambió

La palabra «.NET» aparece pegada a varios nombres distintos según la época del material que estés leyendo, y ahí aparece la segunda fuente de confusión. **.NET Framework** fue la implementación original de la plataforma, publicada en 2002: funcionaba **solo en Windows**, quedaba ligada a la versión del sistema operativo, y durante casi quince años fue prácticamente el único significado posible de «desarrollar en .NET». Hoy está en modo mantenimiento: su última versión es la 4.8.1 y no se planean versiones mayores nuevas.

En 2016 Microsoft presentó **.NET Core**, una reimplementación pensada desde cero para ser **multiplataforma** y de código abierto. En 2020, a partir de la versión que hubiera sido «.NET Core 4», Microsoft decidió unificar el nombre y lanzarla como **«.NET 5»**, sacando la palabra «Core» y saltando deliberadamente el número 4 para que nadie la confundiera con las versiones 4.x de .NET Framework. Desde entonces la numeración es simple y continua: .NET 6, 7, 8, 9 y, al momento de escribir esta guía, .NET 10.

Lo importante para quien empieza hoy es esto: el **.NET moderno** (5 en adelante) corre igual en **Windows, Linux y macOS**. Podés escribir, compilar y ejecutar una aplicación de C# en cualquiera de los tres sistemas, con Visual Studio en Windows o con Visual Studio Code y la terminal en cualquiera de las tres plataformas. Esto es un cambio real frente a la fama que todavía arrastra C# en parte de la comunidad hispanohablante, donde se lo sigue asociando casi exclusivamente a Windows y a Visual Studio. Vale la pena decirlo de forma explícita: el material que hoy circula en el foro de Underc0de sobre C# —incluido un curso de terceros pensado para Visual Studio 2012, hoy desactualizado por la versión— está orientado a ese C# clásico sobre Windows, y no hay todavía ningún hilo dedicado a la CLI de `dotnet` ni al .NET moderno multiplataforma. Esta guía llena justamente ese hueco.

## LTS y STS: qué versión instalar

Microsoft publica una versión nueva de .NET todos los años, en noviembre, y alterna el tipo de soporte según el número: las versiones con número **par** son **LTS** (*Long Term Support*, soporte a largo plazo) y las de número **impar** son **STS** (*Standard Term Support*, soporte estándar, con una ventana más corta). Esta distinción no es un detalle administrativo: decide qué versión conviene instalar según el proyecto.

| Aspecto | LTS (número par) | STS (número impar) |
|---|---|---|
| Duración del soporte | Más larga (años) | Más corta |
| Ejemplo vigente | .NET 10, lanzada el 11/11/2025, con soporte hasta noviembre de 2028 | .NET 9, con fin de soporte el 10/11/2026 |
| Conviene para | Proyectos de largo plazo o en producción | Probar novedades del lenguaje sin compromiso de mantenimiento |

Un dato que conviene tener presente ahora mismo: tanto **.NET 8 como .NET 9 dejan de recibir soporte el 10 de noviembre de 2026**, según la política de soporte que publica Microsoft. Si estás por empezar un proyecto que vas a mantener durante un tiempo, la recomendación práctica es instalar directamente la **LTS vigente** —hoy, .NET 10— en lugar de una versión que va a quedar sin parches de seguridad en pocos meses.

## Instalar el SDK de .NET

Lo que instalás en tu máquina se llama **SDK** (*Software Development Kit*, kit de desarrollo de software): incluye el runtime necesario para ejecutar aplicaciones, el compilador, **MSBuild** (el sistema que orquesta la compilación) y la **CLI de dotnet**, la herramienta de línea de comandos con la que vas a crear, compilar y ejecutar proyectos. No hace falta instalar el runtime por separado: el SDK ya lo incluye.

- **Windows:** se puede descargar el instalador oficial desde la página de descargas de .NET, o instalarlo con **winget**, el gestor de paquetes que trae Windows.
- **Linux (Ubuntu):** Microsoft documenta `apt-get install dotnet-sdk-10.0` como forma de instalación desde los repositorios oficiales.
- **macOS:** con el instalador `.pkg` oficial, o mediante Homebrew.

> **Salvedad importante en Linux**
>
> Microsoft advierte que el paquete `dotnet-sdk-10.0` puede no estar disponible en los repositorios de todas las versiones y regiones de Ubuntu. Si `apt-get` no encuentra el paquete, la alternativa documentada es el script oficial `dotnet-install.sh`, que descarga e instala el SDK sin depender del gestor de paquetes de la distribución. No asumas que el comando de `apt` va a funcionar siempre: verificalo primero.

```bash
# Ubuntu: instalación desde los repositorios oficiales
sudo apt-get update
sudo apt-get install -y dotnet-sdk-10.0

# Si el paquete no está disponible en tu versión/región, usá el script oficial
curl -sSL https://dot.net/v1/dotnet-install.sh -o dotnet-install.sh
bash dotnet-install.sh --channel 10.0

# En cualquier sistema, así verificás que quedó instalado
dotnet --version
```

Sea cual sea el sistema operativo, terminá siempre con `dotnet --version`: si te devuelve un número como `10.0.1xx`, el SDK quedó instalado y ya podés seguir con el resto de la guía.

## Tu primer «Hola, mundo» sin proyecto

Antes de crear una carpeta, un archivo de proyecto y toda la estructura habitual, conviene aprovechar una novedad de **.NET 10**: la posibilidad de ejecutar un único archivo `.cs` suelto, sin generar un proyecto ni un archivo `.csproj`. Es la forma más directa de confirmar que el SDK quedó bien instalado y de ver un programa de C# corriendo por primera vez, sin ceremonias.

```csharp
// hola.cs
Console.WriteLine("¡Hola, mundo!");
```

```bash
# Ejecuta el archivo suelto, sin crear ningún proyecto
dotnet hola.cs
```

Con eso alcanza: el SDK compila el archivo por detrás y ejecuta el resultado en el mismo paso, mostrando `¡Hola, mundo!` en la terminal. Este atajo es ideal para probar un fragmento de código, seguir un ejemplo de la documentación o confirmar una sintaxis antes de entender qué es exactamente un proyecto, que es el tema de la próxima sección.

## Crear y ejecutar un proyecto real

Un archivo suelto sirve para probar, pero cualquier aplicación real —con más de un archivo, con dependencias externas, con configuración propia— necesita un **proyecto**. En .NET, un proyecto es básicamente una carpeta con un archivo `.csproj` (un archivo XML que describe cómo compilar ese código) y el código fuente en archivos `.cs`.

1. **Crear el proyecto.** `dotnet new console -o MiPrimeraApp` genera una carpeta llamada `MiPrimeraApp` con un archivo `MiPrimeraApp.csproj` y un `Program.cs` con el clásico «Hola, mundo» ya escrito.
2. **Entrar a la carpeta.** `cd MiPrimeraApp`. A partir de acá, todos los comandos de `dotnet` se ejecutan dentro de esta carpeta, donde está el `.csproj`.
3. **Ejecutarlo.** `dotnet run` compila el proyecto (si hubo cambios) y lo ejecuta en un solo paso, mostrando la salida en la terminal.
4. **Compilarlo sin ejecutar.** `dotnet build` genera los archivos compilados en la carpeta `bin/` sin correr el programa. Sirve para verificar que el código compila sin errores, o para preparar los binarios que otra herramienta va a ejecutar después.

La diferencia entre este camino y el del archivo suelto no es de lenguaje ni de sintaxis: es que acá hay una carpeta, un archivo de proyecto y, con el tiempo, la posibilidad de sumar más archivos `.cs` y paquetes externos. Cuando tu programa deja de ser un experimento de una línea, este es el camino que vas a necesitar.

## Qué hace cada comando de la CLI

La **CLI** (interfaz de línea de comandos) de `dotnet` es la herramienta central para trabajar con .NET desde la terminal, la uses con Visual Studio Code, con otro editor o directamente sin editor. Estos son los comandos que ya usaste en esta guía, reunidos en una tabla de referencia rápida.

| Comando | Qué hace |
|---|---|
| `dotnet archivo.cs` | Ejecuta un único archivo `.cs` suelto, sin crear proyecto (novedad de .NET 10). |
| `dotnet new console -o Nombre` | Crea un proyecto nuevo de consola en la carpeta `Nombre`, a partir de una plantilla. |
| `dotnet run` | Compila el proyecto de la carpeta actual (si hace falta) y lo ejecuta en un solo paso. |
| `dotnet build` | Compila el proyecto sin ejecutarlo y genera los binarios en `bin/`. |
| `dotnet --version` | Muestra la versión del SDK instalado. Sirve para verificar la instalación. |

Un matiz que conviene recordar: `dotnet run` vuelve a compilar solo si detecta cambios desde la última compilación, así que ejecutarlo repetidas veces sin haber modificado nada no vuelve a compilar todo desde cero. Y `dotnet build` no borra ni reemplaza lo que genera `dotnet run`: son la misma compilación vista desde dos comandos distintos, uno que además ejecuta el resultado y otro que se queda solo con generarlo.

## Tu primer programa, línea por línea

Cuando corrés `dotnet new console`, el archivo `Program.cs` que se genera hoy es mucho más corto de lo que era hace algunos años, y eso suele desconcertar a quien aprendió con tutoriales viejos (incluidos varios que circulan en el foro, pensados para versiones anteriores de C# y de Visual Studio). El contenido generado es, esencialmente, esta única línea:

```csharp
// Program.cs
Console.WriteLine("Hello, World!");
```

Esto funciona gracias a las **instrucciones de nivel superior** (*top-level statements*), una característica del lenguaje C# que le permite al compilador generar automáticamente, por detrás, el punto de entrada del programa: una clase llamada `Program` con un método `Main`, que es tradicionalmente el primer código que se ejecuta en cualquier aplicación de C#. También por eso no hace falta escribir `using System;` al principio: el archivo de proyecto (`.csproj`) que genera `dotnet new` activa por defecto los *usings* implícitos, que agregan automáticamente las referencias más comunes, entre ellas la del espacio de nombres `System`, donde vive la clase `Console`.

Si veniste de un tutorial más antiguo, probablemente hayas visto la forma explícita equivalente, que sigue siendo perfectamente válida y compila igual:

```csharp
using System;

namespace HolaMundo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}
```

Las dos versiones hacen exactamente lo mismo. La diferencia es que la primera es la que genera el SDK moderno por defecto —pensada para que el primer contacto con el lenguaje sea lo más simple posible— y la segunda es la forma explícita que vas a seguir encontrando en documentación, cursos y foros más antiguos, incluidos los de la comunidad. Entender que ambas son «lo mismo por dentro» evita la sensación de estar aprendiendo dos lenguajes distintos según qué material estés leyendo.

## Errores frecuentes

- **Confundir C# con .NET.** Uno es el lenguaje que escribís; el otro, la plataforma que lo ejecuta. Podés cambiar de plataforma de despliegue sin cambiar de lenguaje, y viceversa.
- **Creer que C# solo sirve para Windows y Visual Studio.** El .NET moderno es multiplataforma: se desarrolla igual en Windows, Linux y macOS, con Visual Studio Code y la CLI.
- **No distinguir LTS de STS al instalar.** Instalar una versión STS para un proyecto de largo plazo significa tener que migrar antes de lo esperado.
- **Crear un proyecto completo solo para probar tres líneas.** Desde .NET 10, un archivo `.cs` suelto con `dotnet archivo.cs` alcanza para probar un fragmento.
- **Asumir que el paquete de Linux siempre está disponible.** El comando `apt-get install dotnet-sdk-10.0` puede fallar según la versión o región; ahí entra el script `dotnet-install.sh`.
- **Confundir `dotnet build` con `dotnet run`.** El primero solo compila; el segundo compila (si hace falta) y además ejecuta el programa.

## Preguntas frecuentes

**¿Cuál es la diferencia entre C#, .NET y .NET Framework?**
C# es un lenguaje de programación: la sintaxis, los tipos, las clases y las reglas que escribís en un archivo de texto. .NET es la plataforma que ejecuta ese código: incluye un runtime, el CLR (Common Language Runtime), que corre el código intermedio compilado, y una biblioteca de clases base (BCL) con funcionalidad ya resuelta para archivos, colecciones, texto o red. El SDK, a su vez, es el kit que instalás en tu computadora para poder compilar y ejecutar: trae el compilador, MSBuild y la CLI de dotnet. .NET Framework es la implementación original de esta plataforma, publicada en 2002, exclusiva de Windows y ligada a la versión del sistema operativo; hoy está en mantenimiento, sin nuevas versiones mayores previstas. En 2016 apareció .NET Core, una reimplementación multiplataforma, y en 2020, a partir de la versión 5, Microsoft eliminó la palabra «Core» del nombre y unificó todo bajo «.NET» a secas, saltando del 4 al 5 para no confundirlo con las versiones 4.x de .NET Framework. En la práctica, cuando alguien dice «.NET» hoy se refiere a esta línea moderna y multiplataforma, no al .NET Framework original.

**¿Necesito Visual Studio o puedo usar VS Code?**
Podés usar cualquiera de los dos: la elección no cambia el código que se ejecuta, porque ambos terminan apoyándose en el mismo SDK y en la misma CLI de dotnet por debajo. Visual Studio es el entorno de desarrollo integrado completo de Microsoft, con depurador visual, diseñador de interfaces y muchísimas herramientas integradas, pero solo está disponible para Windows. Visual Studio Code, en cambio, es un editor de código más liviano y gratuito que corre en Windows, Linux y macOS, y que con la extensión de C# (o el conjunto de extensiones para el ecosistema .NET) permite escribir, depurar y ejecutar proyectos sin salir del editor, apoyándose en la terminal integrada para invocar los comandos de dotnet. Esta es justamente la gran diferencia entre .NET Framework, que dependía de Windows y de Visual Studio, y el .NET moderno, que es multiplataforma de verdad: podés desarrollar en Linux o macOS con VS Code y la terminal, sin necesitar Windows en ningún momento del proceso. La recomendación práctica para quien empieza es simple: si ya tenés Windows y te gusta un entorno todo en uno, Visual Studio tiene una curva de aprendizaje más guiada; si preferís algo liviano, multiplataforma o ya usás VS Code para otros lenguajes, te va a alcanzar perfectamente con el SDK y la CLI.

**¿Qué versión de .NET instalo: la LTS o la más nueva?**
Depende de para qué la vayas a usar, y la clave está en distinguir dos tipos de lanzamiento. Las versiones LTS (Long Term Support, soporte a largo plazo) reciben actualizaciones y parches de seguridad durante un período extendido, mientras que las versiones STS (Standard Term Support, soporte estándar) tienen una ventana de soporte más corta pero suelen incorporar antes las novedades más recientes del lenguaje y del runtime. Microsoft alterna el tipo de lanzamiento según el número de versión: las pares son LTS (.NET 8, .NET 10) y las impares son STS (.NET 9). Al momento de escribir esta guía, .NET 10 es la LTS vigente, lanzada el 11 de noviembre de 2025, con tres años de soporte, es decir hasta noviembre de 2028. .NET 8 y .NET 9, en cambio, tienen fecha de fin de soporte el 10 de noviembre de 2026, según la política de soporte publicada por Microsoft. Para un proyecto de largo plazo, uno que vas a mantener durante años o vas a llevar a producción, conviene instalar siempre la LTS vigente, porque te da más tiempo antes de tener que migrar. Para experimentar, aprender o probar una función nueva del lenguaje sin compromiso de mantenimiento, una STS también sirve, pero hay que tener presente que su ciclo de vida es más corto y que vas a necesitar actualizar antes.

**¿C# sirve para desarrollo web y no solo para escritorio?**
Sí. C# nació asociado a aplicaciones de escritorio de Windows, y esa fama todavía persiste en parte de la comunidad hispanohablante, pero el ecosistema .NET incluye desde hace años un framework web propio, ASP.NET Core, que corre sobre el mismo runtime multiplataforma que usás para una aplicación de consola y permite construir APIs, sitios web y servicios en Windows, Linux o macOS por igual. Con el mismo lenguaje y la misma plataforma también se construyen aplicaciones móviles, servicios en la nube, herramientas de línea de comandos y videojuegos, entre otros usos. Esta guía se concentra deliberadamente en los fundamentos —qué es cada pieza del ecosistema, cómo se instala y cómo se ejecuta el primer programa de consola—, porque es la base que necesitás antes de meterte con un framework web o con cualquier otro tipo de proyecto más específico. Una vez que entendés cómo se relacionan el lenguaje, la plataforma, el SDK y la CLI, pasar a un proyecto de ASP.NET Core es sobre todo aprender una capa nueva de conceptos (rutas, controladores, inyección de dependencias) que se apoya en exactamente el mismo dotnet new, dotnet build y dotnet run que ya vas a conocer.

**¿Cómo creo y ejecuto mi primer programa desde la terminal?**
Hay dos caminos, y esta guía los explica en ese orden porque conviene aprenderlos así. El primero, disponible desde .NET 10, es ejecutar un único archivo .cs suelto sin crear ningún proyecto: escribís un archivo, por ejemplo hola.cs, con una sola línea como Console.WriteLine("¡Hola, mundo!"); y lo ejecutás directamente con dotnet hola.cs, sin generar carpetas ni archivos de proyecto. Es la forma más rápida de confirmar que el SDK está bien instalado y de probar un fragmento de código sin ceremonias. El segundo camino, el que vas a usar para cualquier aplicación real, empieza con dotnet new console -o NombreApp, que crea una carpeta con un archivo de proyecto (.csproj) y un archivo de código fuente (Program.cs) ya con una plantilla de «Hola, mundo». Desde esa carpeta, dotnet run compila el proyecto si hace falta y lo ejecuta en un solo paso, mientras que dotnet build solo compila, sin ejecutar, algo útil para verificar que el código compila sin errores o para preparar los binarios que después va a ejecutar otra herramienta. La diferencia entre ambos caminos no es de lenguaje: es que uno arranca sin proyecto y el otro sí lo crea, y a medida que tu programa crece vas a necesitar la estructura de proyecto para agregar más archivos, paquetes y configuración.

**¿.NET Core, .NET 5+ y .NET a secas son lo mismo?**
Son la misma línea de producto en distintos momentos de su historia, y entenderlo evita mucha confusión al leer documentación o tutoriales de distintos años. En 2016 Microsoft lanzó .NET Core 1.0, una reimplementación multiplataforma y de código abierto pensada para convivir con el ya existente .NET Framework, que seguía siendo exclusivo de Windows. .NET Core fue creciendo por varias versiones (1.x, 2.x, 3.x) hasta 3.1. En 2020, con la intención de unificar el ecosistema en una sola plataforma hacia adelante, Microsoft lanzó la versión siguiente como «.NET 5», eliminando la palabra «Core» del nombre y saltando deliberadamente del número 4 al 5 para que nadie la confundiera con .NET Framework 4.x, que es una plataforma distinta y separada. Desde entonces, las versiones se numeran de forma simple y consecutiva —.NET 6, 7, 8, 9, 10— con un lanzamiento anual, alternando entre soporte a largo plazo (LTS) en las versiones pares y soporte estándar (STS) en las impares. Entonces, si ves «.NET Core 3.1» en un tutorial viejo y «.NET 8» o «.NET 10» en uno reciente, ambos pertenecen a la misma línea moderna y multiplataforma; lo que cambió es solo el nombre y el número, no la naturaleza de la plataforma. La única que queda realmente aparte, y en mantenimiento, es el .NET Framework original.

## Fuentes

Documentación oficial y material de la comunidad consultados para esta guía. Fecha de consulta: 29 de julio de 2026.

### Aportes de la comunidad Underc0de

1. **Underc0de, foro.** [Curso básico introductorio de C#](https://underc0de.org/foro/visual-studio-net/curso-basico-introductorio-de-c/), por *Rex*, sección C# - VB.NET (8 de diciembre de 2019). Antecedente del interés de la comunidad por C#: anuncia un videocurso propio orientado a quienes se inician, sin código en el hilo. En el foro no hay, hasta la fecha de consulta, ningún hilo dedicado a la CLI de dotnet ni al .NET moderno multiplataforma; el resto del material disponible está orientado a C# clásico sobre Windows y Visual Studio.

### Documentación oficial

1. **Microsoft.** [Guía de C#](https://learn.microsoft.com/en-us/dotnet/csharp/). Referencia central del lenguaje.
2. **Microsoft.** [.NET download 10.0](https://dotnet.microsoft.com/en-us/download/dotnet/10.0). Instaladores oficiales del SDK por sistema operativo.
3. **Microsoft.** [.NET support policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core). Fechas de soporte de cada versión y política LTS/STS.
4. **Microsoft.** [dotnet new (referencia de la CLI)](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-new). Documentación del comando para crear proyectos.
5. **Microsoft.** [Hello World — Tour of C#](https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/hello-world). Tutorial oficial del primer programa, incluidas las instrucciones de nivel superior.
6. **Microsoft.** [Install .NET on Ubuntu](https://learn.microsoft.com/en-us/dotnet/core/install/linux-ubuntu-install). Instrucciones y salvedades de instalación en Linux.

## Guías relacionadas

- [Programación orientada a objetos desde cero](../programacion-orientada-a-objetos-desde-cero/index.md)
- [Cómo aprender programación desde cero](../aprender-programacion-desde-cero/index.md)
- [Principios SOLID explicados con ejemplos sencillos](../principios-solid-con-ejemplos-sencillos/index.md)
- [Clean Code: cómo escribir código limpio y mantenible](../clean-code-codigo-limpio-y-mantenible/index.md)
- [Índice de Programación](../index.md)