.NET 10

.NET 10 LTS: todas las novedades explicadas para desarrolladores

.NET 10 LTS: todas las novedades explicadas para desarrolladores

El 11 de noviembre de 2025 Microsoft lanzó oficialmente .NET 10 junto con C# 14, ASP.NET Core 10, EF Core 10 y nuevas versiones de MAUI y las herramientas de desarrollo. Es una versión LTS (Long-Term Support), con soporte hasta el 14 de noviembre de 2028.

En este artículo vamos a repasar, con calma y en detalle, qué cambia realmente en .NET 10, cómo impacta tu código del día a día y qué deberías ir planificando si vienes de .NET 6/7/8/9.

1. Contexto: qué es .NET 10 y por qué importa

Al igual que .NET 6, .NET 10 es una versión unificadora y de largo plazo:

  • Marco común para:
    • Aplicaciones web (ASP.NET Core 10).
    • APIs y servicios cloud-native (.NET + ASP.NET Core + .NET Aspire).
    • Aplicaciones de escritorio (WinForms y WPF).
    • Aplicaciones móviles y multiplataforma (MAUI 10).
    • Acceso a datos moderno (EF Core 10).
  • Lenguaje principal: C# 14, con cambios importantes de productividad y expresividad.
  • Fuerte enfoque en:
    • Rendimiento y Native AOT.
    • Experiencia de desarrollo (CLI, MSBuild, herramientas).
    • Seguridad moderna (incluyendo criptografía post-cuántica).
    • Soporte para escenarios de IA y búsqueda vectorial/híbrida (EF Core 10, SQL Server 2025, Cosmos DB).

Para proyectos nuevos que necesitan estabilidad a largo plazo, .NET 10 LTS se convierte en el nuevo objetivo natural.

2. Novedades clave en el SDK y la CLI de .NET 10

La parte menos “visible” para el usuario final, pero muy relevante para nosotros como desarrolladores, es el SDK y la CLI. Microsoft ha invertido bastante aquí.

2.1. File-based apps: C# como “script” de primera clase

La novedad más llamativa del SDK son las file-based apps:

  • Puedes ejecutar directamente un archivo .cs sin proyecto ni solución:
dotnet run app.cs
  • En ese único archivo puedes:
    • Declarar el SDK:
      #:sdk Microsoft.NET.Sdk.Web
    • Referenciar paquetes NuGet:
      #:package [email protected]
    • Referenciar proyectos existentes con #:project.

Esto coloca a C# en una posición similar a Python o Node.js para:

  • Scripts de automatización.
  • Herramientas internas.
  • Prototipos rápidos.

Además, .NET 10 permite publicar estas file-based apps como ejecutables nativos (Native AOT) usando:

dotnet publish app.cs

Por defecto, las file-based apps tienen Native AOT activado; si un paquete no lo soporta, puedes desactivarlo con:

#:property PublishAot=false

2.2. Herramientas .NET: ejecución “one-shot” y script dnx

Para las .NET tools, el SDK introduce:Microsoft Learn

  • dotnet tool exec: ejecutar una herramienta sin instalarla globalmente.
dotnet tool exec --source ./artifacts/package/ dotnetsay "Hola"

Script dnx para simplificar la ejecución de herramientas:

dnx dotnetsay "Hola"

2.3. Mejoras en la experiencia de la CLI

Algunos cambios de calidad de vida:

  • Nueva opción --cli-schema en cualquier comando para obtener un árbol JSON de la estructura de comandos (útil para integraciones con shells, herramientas, autocompletado).Microsoft Learn
  • Nuevos alias de comandos con forma “nombre-verbo”:
    • dotnet package add (alias de dotnet add package).
    • dotnet package list, dotnet package remove, etc.Microsoft Learn
  • Comandos interactivos con --interactive activo por defecto en terminales interactivos.
  • dotnet completions generate para generar scripts de autocompletado nativo en bash, zsh, PowerShell, etc.Microsoft Learn
  • Las apps de consola pueden publicarse como imágenes de contenedor directamente con dotnet publish /t:PublishContainer, sin configurar <EnableSdkContainerSupport>.Microsoft Learn

2.4. Auditoría de paquetes y pruning automático

El SDK integra con NuGet Audit la capacidad de “podar” referencias de paquetes que ya aporta el runtime:

  • Menos paquetes descargados, menos ruido en auditorías de seguridad.
  • Proyectos más limpios y builds más rápidos.Microsoft Learn

3. Cambios en el runtime y las bibliotecas de .NET

Aunque el runtime evoluciona de forma incremental, la combinación de mejoras hace que .NET 10 sea un entorno más preparado para cloud, contenedores y IA.Visual Studio Magazine

3.1. Rendimiento, AOT y contenedores

De forma resumida:

  • Mejoras continuas en JIT y Native AOT para reducir memoria y mejorar tiempo de arranque.
  • Escenarios de contenerización más pulidos, con soporte directo a PublishContainer para apps de consola y servicios.Microsoft Learn

3.2. Librerías base y criptografía post-cuántica

En las bibliotecas de .NET 10 destacan:Visual Studio Magazine

  • APIs de criptografía post-cuántica más completas, preparadas para estándares emergentes.
  • Nuevos tipos de tensores (Tensor, TensorSpan, ReadOnlyTensorSpan) para escenarios numéricos y de IA.Visual Studio Magazine
  • Utilidades como conversiones de cadenas hex UTF-8 más eficientes.

Todo esto apunta a un .NET más preparado para cargas de IA, procesamiento numérico y seguridad a largo plazo.

4. Novedades de C# 14

C# 14 acompaña a .NET 10 y trae cambios que facilitan escribir código limpio y expresivo.Anton Dev Tips

4.1. Extension members

Evolución natural de los métodos de extensión:

  • Ahora puedes declarar bloques extension que agrupan métodos, propiedades y miembros estáticos para un tipo concreto:
public static class StringExtensions
{
    extension(string value)
    {
        public bool IsNullOrEmpty() => string.IsNullOrEmpty(value);

        public string Truncate(int maxLength)
        {
            if (string.IsNullOrEmpty(value) || value.Length <= maxLength)
                return value;

            return value.Substring(0, maxLength);
        }
    }
}
  • Soporte para:
    • Métodos de instancia.
    • Propiedades de instancia.
    • Métodos estáticos de extensión.
    • Propiedades estáticas de extensión.Anton Dev Tips

Esto permite crear APIs de extensión más coherentes, con estado interno (cachés, etc.), sin perder la semántica de extensión.

4.2. Propiedades de extensión y campos privados

Dentro del bloque extension puedes tener campos privados y propiedades calculadas:

public static class CollectionExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        private List<T>? _materialized;
        public List<T> Materialized => _materialized ??= source.ToList();

        public bool IsEmpty => Materialized.Count == 0;
    }
}

Esto simplifica patrones de lazy loading, recuentos, materialización, etc.Anton Dev Tips

4.3. Asignación condicional nula

Los operadores ?. y ?[] ahora se pueden usar en asignaciones:

user?.Profile = LoadProfile();

Evitas el patrón clásico:

if (user is not null)
{
    user.Profile = LoadProfile();
}

4.4. Palabra clave field

Nueva palabra clave field para usar el campo de respaldo implícito en propiedades autoimplementadas:

public class Config
{
    public string FilePath
    {
        get => field ??= "data/config.json";
        set => field = value ?? throw new ArgumentNullException(nameof(value));
    }
}

Te ahorras declarar campos privados solo para inicialización perezosa o validaciones simples.Anton Dev Tips

4.5. Otras mejoras de C# 14

  • Modificadores (out, ref, in, scoped, ref readonly) en parámetros de lambdas sin necesidad de declarar tipos explícitos.Anton Dev Tips
  • Soporte para constructores y eventos parciales, muy útil para generadores de código.

5. ASP.NET Core 10 y Blazor: web moderna y más segura

ASP.NET Core 10 trae una mezcla de mejoras en Blazor, APIs mínimas, identidad y rendimiento.Microsoft Learn

5.1. Blazor: rendimiento, diagnóstico y mejor experiencia de desarrollo

En la documentación oficial se destacan varios cambios importantes en Blazor:Microsoft Learn

  • Nuevas muestras de seguridad para Blazor Web App:
    • Integración con OpenID Connect (OIDC) y Microsoft Entra ID.
    • Ejemplos con Web API externa y configuración desde appsettings.json.Microsoft Learn
  • El script de Blazor ahora se sirve como activo estático con compresión y fingerprinting automático, mejorando cacheo y despliegues.Microsoft Learn
  • Mejora de la navegación:
    • NavigateTo ya no fuerza scroll al principio para navegaciones en la misma página.Microsoft Learn
  • Reconexion UI mejorada:
    • Plantilla con componente ReconnectModal que respeta políticas CSP estrictas y expone mejor el estado de reconexión.Microsoft Learn
  • HttpClient en Blazor WebAssembly ahora usa streaming de respuestas por defecto, lo que mejora el rendimiento en cargas grandes (con opción de desactivar).Microsoft Learn
  • Fingerprints de recursos en el cliente para Blazor WebAssembly standalone, mediante marcadores en index.html y propiedades MSBuild.Microsoft Learn
  • Nuevo modelo declarativo de estado persistente con [PersistentState], simplificando el uso de PersistentComponentState frente al patrón manual clásico.Microsoft Learn
  • Mejoras de interop con JavaScript:
    • InvokeConstructorAsync, GetValueAsync, SetValueAsync (y versiones síncronas).Microsoft Learn
  • Nuevas herramientas de profiling y diagnósticos para Blazor WebAssembly.Microsoft Learn

En conjunto, Blazor 10 se siente más maduro para aplicaciones grandes, con mejor soporte para SSR, WebAssembly, seguridad y rendimiento.

5.2. APIs mínimas, Identity y OpenAPI

Aunque el artículo oficial de ASP.NET Core 10 es muy extenso, los resúmenes públicos señalan mejoras en:Visual Studio Magazine

  • Validación en APIs mínimas y Blazor más consistente.
  • Mejoras en la generación de esquemas OpenAPI, facilitando documentar APIs.
  • Identity:
    • Soporte integrado para Passkeys como mecanismo de autenticación moderna y resistente al phishing.Visual Studio Magazine

Para proyectos que ya usan ASP.NET Core, la migración a .NET 10 te da acceso a una pila web más segura y preparada para WebAssembly + SSR en escenarios reales.

6. EF Core 10: datos listos para IA, JSON y consultas avanzadas

Entity Framework Core 10 (EF10) se apoya mucho en las capacidades nuevas de SQL Server 2025, Azure SQL y Cosmos DB, con un foco claro en IA, JSON y modelado complejo.Microsoft Learn

6.1. Azure SQL / SQL Server 2025

Novedades principales:Microsoft Learn

  1. Vector search (embeddings)
    • Soporte completo para el tipo vector en Azure SQL y SQL Server 2025.
    • Puedes guardar embeddings en propiedades SqlVector<float> y usar EF.Functions.VectorDistance en LINQ para búsquedas de similitud:
var topBlogs = context.Blogs
    .OrderBy(b => EF.Functions.VectorDistance("cosine", b.Embedding, queryVector))
    .Take(3)
    .ToListAsync();
  1. Tipo json nativo
    • EF mapea automáticamente colecciones primitivas y tipos complejos a columnas json cuando usas Azure SQL o SQL Server 2025 (compat level 170+).Microsoft Learn
    • Puedes consultar propiedades internas del JSON en LINQ y EF genera JSON_VALUE(... RETURNING ...) correspondiente.

6.2. Cosmos DB: full-text y búsqueda híbrida

Para Azure Cosmos DB for NoSQL:Microsoft Learn

  • Soporte para Full-text search con funciones como FullTextContains, FullTextContainsAll, FullTextScore.Microsoft Learn
  • Soporte para búsqueda híbrida con RRF (Reciprocal Rank Fusion) combinando full-text + vector similarity:
var results = await context.Blogs
    .OrderBy(x => EF.Functions.Rrf(
        EF.Functions.FullTextScore(x.Contents, "database"),
        EF.Functions.VectorDistance(x.Vector, myVector)))
    .Take(10)
    .ToListAsync();

6.3. Complex types mejorados

EF Core ya soportaba modelado con entidades “owned”; ahora se consolidan los complex types:Microsoft Learn

  • Complex types opcionales:
public class Customer
{
    public int Id { get; set; }
    public Address ShippingAddress { get; set; }
    public Address? BillingAddress { get; set; }
}
  • Mapeo a columnas normales (table splitting) o a columnas JSON con .ToJson().
  • Soporte para complex types basados en structs, alineando el concepto de tipo sin identidad.Microsoft Learn

6.4. LINQ y consultas: LeftJoin, RightJoin, JSON y filtros

En la práctica diaria se agradecen:learnentityframeworkcore.com

  • Nuevos métodos LINQ LeftJoin y RightJoin, que simplifican mucho la escritura de joins típicos.
  • ExecuteUpdateAsync ahora soporta actualizar propiedades en columnas JSON.
  • Filtros de consulta con nombre:
    • Permiten tener múltiples filtros globales (por ejemplo, soft delete + multi-tenancy) y activar/desactivar de forma independiente.
  • ExecuteUpdateAsync permite usar lambdas normales, facilitando actualizaciones condicionales más complejas.Anton Dev Tips

Si trabajas con EF Core intensivamente, EF 10 es una versión que mejora tanto los escenarios de IA (vectores, híbrida) como los de negocio clásico (JSON, filtros globales, joins).

7. .NET MAUI en .NET 10: calidad, controles y diagnóstico

En .NET 10, el foco de MAUI es mejorar la calidad general, pero hay muchas novedades prácticas.Microsoft Learn

7.1. Enfoque en calidad y soporte como workload

  • .NET MAUI se distribuye como workload + paquetes NuGet, lo que facilita:
    • Fijar versiones concretas por proyecto.
    • Probar builds experimentales sin afectar todo el entorno.Microsoft Learn

7.2. Integración con .NET Aspire

  • Nuevo template que añade un proyecto de service defaults de .NET Aspire para MAUI:
    • Telemetría con OpenTelemetry.
    • Service discovery.
    • Configuración automática de HttpClient para descubrimiento de servicios.Microsoft Learn

7.3. Cambios en controles y API

Algunos ejemplos claros:Microsoft Learn

  • Métodos de animación como FadeTo, RotateTo, etc., pasan a versiones asíncronas (FadeToAsync, RotateToAsync, etc.).
  • ListView y varias celdas (EntryCell, ImageCell, etc.) se deprecian definitivamente; se recomienda CollectionView.Microsoft Learn
  • HybridWebView:
    • Nuevo InvokeJavaScriptAsync.
    • Eventos para inicialización (WebViewInitializing, WebViewInitialized).
    • Capacidad para interceptar solicitudes web desde BlazorWebView y HybridWebView.Microsoft Learn
  • DatePicker y TimePicker ahora soportan valores nullable.Microsoft Learn

7.4. Diagnósticos y rendimiento de layout

  • Instrumentación detallada de layout (measure, arrange) con métricas (maui.layout.measure_*, maui.layout.arrange_*) via ActivitySource y Meter.Microsoft Learn

7.5. XAML Source Generator y namespaces implícitos

  • Source generator para XAML que genera código fuertemente tipado y mejora tiempos de compilación.
  • Nueva experiencia de namespaces XML globales e implícitos para reducir ruido en cabeceras de XAML.Microsoft Learn

En conjunto, MAUI 10 se orienta a que las apps grandes sean más mantenibles, diagnósticables y alineadas con patrones modernos.

8. Escritorio: WinForms y WPF en .NET 10

Aunque no son el foco mediático, las aplicaciones de escritorio siguen recibiendo cariño:Visual Studio Magazine

  • WinForms:
    • Soporte completo de modo oscuro integrado.
    • Mejoras en temas y correcciones de compatibilidad.
  • WPF:
    • Actualización centrada en calidad, correcciones y estabilidad, sin cambios radicales.

Si mantienes aplicaciones de escritorio, .NET 10 te ofrece un entorno más moderno, con mejoras visuales y compatibilidad prolongada.

9. .NET 10 y la ola de IA: dónde encaja

Sin entrar en bibliotecas específicas, .NET 10 se alinea con escenarios de IA de varias maneras:

  • EF Core 10 + SQL Server 2025:
  • EF Core 10 + Cosmos DB:
    • Full-text search + vector search + RRF para búsqueda híbrida.Microsoft Learn
  • Librerías de .NET:
  • MAUI + .NET Aspire:
    • Telemetría y distribución de servicios lista para microservicios y apps conectadas.Microsoft Learn

Todo esto convierte a .NET 10 en una base sólida para proyectos que combinen aplicaciones tradicionales + IA + cloud.

10. ¿Debo migrar a .NET 10? Recomendaciones prácticas

Algunas pautas generales:

  1. Proyectos nuevos
    • Si necesitas soporte a largo plazo: empieza directamente en .NET 10 LTS.
    • Aprovecha C# 14, EF Core 10 y ASP.NET Core 10 desde el inicio.
  2. Proyectos en .NET 6 (LTS antiguo)
    • Empieza a planificar migración: .NET 10 te da un nuevo ciclo de 3 años, mejor rendimiento y mejoras notables en web, datos y tooling.
  3. Proyectos en .NET 7/8/9
    • Si son proyectos activos, conviene ir preparando la migración a 10 para consolidar en una versión LTS estable y beneficiarte de:
      • File-based apps para herramientas internas.
      • EF Core 10 (vectores, JSON, filtros, joins).
      • ASP.NET Core 10 con Blazor más maduro y soporte de Passkeys.
  4. Aplicaciones de escritorio o MAUI
    • Si dependes de WinForms/WPF/MAUI y quieres longevidad, .NET 10 es un buen objetivo intermedio para estabilizar la base de código.

.NET 10 no es solo “una versión más”: consolida varias tendencias que venían desde .NET 6/7/8/9:

  • C# más expresivo (C# 14).
  • Herramientas más amigables (dotnet CLI, file-based apps, Native AOT).
  • Plataforma preparada para IA y motores de búsqueda modernos (vectores, JSON, full-text, híbrida).
  • Web más sólida con Blazor, APIs mínimas y seguridad moderna (Passkeys, mejores muestras y diagnósticos).
  • Ecosistema multiplataforma (MAUI, escritorio, cloud, contenedores) más maduro.

Si tu objetivo es tener aplicaciones que puedan vivir y crecer durante varios años, .NET 10 LTS se convierte en una base natural para tus próximos proyectos.

Continúa aprendiendo .NET con cursos profesionales

Si deseas llevar tu dominio de .NET al siguiente nivel —incluyendo APIs, EF Core, Blazor, Clean Architecture y las nuevas tecnologías de .NET 10— te invito a explorar mis cursos completos y actualizados. Son contenido profundo, práctico y estructurado para que avances de forma sólida y profesional.

Encuentra todas las opciones disponibles aquí:
https://render2web.com/promociones

Deja un comentario