En esta página

Qué es .NET 10 y C# 14: ecosistema, CLR y primer proyecto

12 min lectura TextoCap. 1 — Fundamentos de C#

¿Qué es .NET?

.NET es la plataforma de desarrollo de Microsoft, de código abierto, multiplataforma y de propósito general. Con ella puedes construir desde aplicaciones de consola hasta APIs web, aplicaciones de escritorio, servicios en la nube, aplicaciones móviles y juegos.

.NET 10 es la versión LTS (Long Term Support) lanzada en noviembre de 2025. Significa tres años de soporte oficial, lo que la convierte en la opción ideal para proyectos empresariales y de larga duración.

El ecosistema .NET en 2025

.NET 10 (plataforma unificada)
├── ASP.NET Core 10   → APIs web, MVC, Razor Pages, Blazor
├── EF Core 10        → ORM para bases de datos relacionales
├── .NET MAUI         → Aplicaciones móviles y de escritorio
├── ML.NET            → Machine Learning
├── Orleans           → Sistemas distribuidos
└── Blazor            → Web con C# en el navegador (WASM)

La plataforma corre en Windows, Linux y macOS con rendimiento de primera clase en todos los sistemas operativos.

¿Qué es C#?

C# (pronunciado "C sharp") es el lenguaje principal del ecosistema .NET. Es un lenguaje:

  • Fuertemente tipado — los errores se detectan en tiempo de compilación
  • Orientado a objetos — con clases, herencia e interfaces
  • Moderno — con características funcionales: LINQ, records, pattern matching
  • Seguro — gestión automática de memoria mediante el Garbage Collector

C# 14 es la versión actual que se distribuye con .NET 10. Incluye mejoras en genéricos de alias, mejor inferencia de tipos y refinamientos en pattern matching.

El CLR: Common Language Runtime

El CLR (Common Language Runtime) es el motor de ejecución de .NET. Cuando compilas código C#, no obtienes binarios de máquina directamente, sino IL (Intermediate Language), un bytecode independiente de la arquitectura.

Código fuente C# (.cs)
        ↓ Compilación (csc / dotnet build)
   Bytecode IL (.dll / .exe)
        ↓ Ejecución (CLR / JIT o AOT)
  Código máquina nativo

El CLR proporciona:

Servicio Descripción
GC Garbage Collector — gestión automática de memoria
JIT Just-In-Time compilation — IL a código máquina en tiempo de ejecución
AOT Ahead-Of-Time compilation — binarios nativos sin CLR en producción
Type Safety Verificación de tipos en tiempo de ejecución
Exception Handling Sistema unificado de manejo de excepciones
Thread Management Gestión de hilos y el Thread Pool

SDK vs Runtime

Esta distinción es fundamental cuando despliegas aplicaciones:

SDK (Software Development Kit)

  • Incluye el compilador de C# (csc)
  • Incluye el CLI dotnet
  • Incluye el Runtime
  • Incluye las herramientas de diagnóstico
  • Necesario en tu máquina de desarrollo

Runtime

  • Solo incluye el CLR y las librerías base
  • Más ligero (aprox. 25 MB vs 200+ MB del SDK)
  • Suficiente para ejecutar aplicaciones ya compiladas
  • Lo que instalas en servidores de producción

Instalar .NET 10

La forma más sencilla es desde el sitio oficial:

# En Linux (usando el script de instalación)
curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --version 10.0.0

# En macOS con Homebrew
brew install --cask dotnet-sdk

# Verificar la instalación
dotnet --version
# output: 10.0.x

# Ver todos los SDKs instalados
dotnet --list-sdks

# Ver todos los Runtimes instalados
dotnet --list-runtimes

El dotnet CLI

El CLI de .NET es tu herramienta principal de trabajo. Estos son los comandos esenciales:

Comando Descripción
dotnet new console Crear aplicación de consola
dotnet new webapi Crear API web (ASP.NET Core)
dotnet new classlib Crear librería de clases
dotnet run Compilar y ejecutar
dotnet build Solo compilar
dotnet test Ejecutar tests
dotnet add package NombrePaquete Añadir un paquete NuGet
dotnet publish -c Release Publicar para producción
dotnet watch run Hot reload durante el desarrollo

Tu primera aplicación de consola

Vamos a crear una aplicación de consola que muestra información del sistema:

dotnet new console -n HolaMundo -f net10.0
cd HolaMundo

Esto genera un archivo Program.cs con el código mínimo. Modifícalo:

// Program.cs
using System.Runtime.InteropServices;

Console.Title = "Mi primera app .NET 10";
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("╔══════════════════════════════╗");
Console.WriteLine("║  Bienvenido a .NET 10 + C# 14 ║");
Console.WriteLine("╚══════════════════════════════╝");
Console.ResetColor();

// Información del entorno
Console.WriteLine($"\nVersión de .NET: {Environment.Version}");
Console.WriteLine($"Sistema operativo: {RuntimeInformation.OSDescription}");
Console.WriteLine($"Procesador: {RuntimeInformation.ProcessArchitecture}");
Console.WriteLine($"¿Es de 64 bits? {Environment.Is64BitProcess}");

// Input interactivo
Console.Write("\nIngresa tu nombre: ");
string nombre = Console.ReadLine() ?? "Desconocido";
Console.WriteLine($"¡Hola, {nombre}! Estás usando .NET {Environment.Version.Major}.");

Ejecuta con dotnet run y verás la salida en la consola.

Estructura de un proyecto .NET

HolaMundo/
├── HolaMundo.csproj    ← Archivo de proyecto (XML)
├── Program.cs          ← Código fuente principal
└── obj/                ← Archivos temporales de compilación
    └── ...

El archivo .csproj es el corazón del proyecto:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
  </PropertyGroup>
</Project>

Las propiedades clave:

  • Nullable>enable — activa el análisis de nulabilidad (¡muy recomendado!)
  • ImplicitUsings>enable — importa automáticamente System, System.Linq, etc.

NuGet: el gestor de paquetes

NuGet es el equivalente de npm para .NET. El repositorio oficial es nuget.org con más de 300,000 paquetes.

# Añadir un paquete
dotnet add package Newtonsoft.Json --version 13.0.3

# Restaurar paquetes (después de clonar un repo)
dotnet restore

# Listar paquetes instalados
dotnet list package

Práctica

  1. Instala .NET 10 SDK en tu máquina y verifica con dotnet --version.
  2. Crea tu primera aplicación con dotnet new console -n MiApp y modifica Program.cs para mostrar la fecha actual con DateTime.Now.
  3. Explora el CLI: ejecuta dotnet new list para ver todas las plantillas disponibles y crea una de tipo webapi.

En la siguiente lección exploraremos los tipos de datos fundamentales de C#: enteros, decimales, strings, booleanos y cómo usar var, const y los tipos nullables.

SDK vs Runtime
El SDK incluye el compilador, el Runtime y las herramientas CLI. El Runtime solo incluye lo necesario para ejecutar aplicaciones ya compiladas. En producción instala solo el Runtime; en desarrollo necesitas el SDK completo.
.NET 10 es LTS
.NET 10 es una versión LTS (Long Term Support) con 3 años de soporte. Siempre prefiere versiones LTS para proyectos de producción. Las versiones intermedias (11, 12...) tienen soporte de 18 meses.
Instrucciones de nivel superior
Desde C# 9, no necesitas escribir una clase Program con un método Main(). Basta con escribir las instrucciones directamente en Program.cs. El compilador genera la clase y el método de forma automática. 
// Program.cs — .NET 10 / C# 14
// Las instrucciones de nivel superior eliminan la clase Main
using System;
using System.Runtime.InteropServices;

Console.WriteLine("¡Hola, .NET 10!");
Console.WriteLine($"Versión del runtime: {Environment.Version}");
Console.WriteLine($"SO: {RuntimeInformation.OSDescription}");
Console.WriteLine($"Arquitectura: {RuntimeInformation.OSArchitecture}");

// Tipos de alias de C# 14 (type aliases con generics)
using ProductId = int;
using ProductName = string;

ProductId id = 42;
ProductName name = "Laptop Pro";
Console.WriteLine($"Producto #{id}: {name}");