.NET 11 para dummies: qué cambia y cómo empezar

Imagina que haces un pedido en una tienda y la respuesta puede ser «pedido reservado» o «sin existencias». Con C# 15 puedes escribir esas dos opciones en tu código y dejar que el compilador te avise si te olvidas de una. Es uno de los cambios de .NET 11 y lo puedes probar con un pequeño programa.

Si ya tienes una aplicación en .NET 10, puedes probar .NET 11 en otro proyecto y mantener tu aplicación en la versión actual mientras preparas el cambio. En una aplicación web, una primera prueba consiste en comparar qué recibe el navegador antes y después de actualizar.

.NET 11 ya está disponible. Microsoft publicó la versión estable el 10 de noviembre de 2026. Para compilar, descarga el SDK 11.0.100. El runtime que incluye es 11.0.0. Anuncio de Microsoft · Descarga oficial de .NET 11

Cuándo salió .NET 11 y cuánto dura el soporte

STS significa Standard Term Support, con dos años de soporte. LTS significa Long Term Support, con tres años. Como .NET 10 salió un año antes, Microsoft fija el fin de soporte de .NET 10 y .NET 11 para el mismo día. Para mantener el soporte, instala los parches de tu versión. El soporte de RC3 terminó el día que se publicó la versión estable. Política de soporte de .NET

SDK, runtime, C# y net11.0: qué cambia en cada capa

• El SDK trae el compilador, la CLI y las herramientas para restaurar paquetes, compilar y publicar. global.json ayuda a fijar qué SDK usa el repositorio.
• net11.0 es el Target Framework Moniker o TFM. En el .csproj indica el marco de destino contra el que compilas.
• C# 15 es la versión de lenguaje que se selecciona por defecto al apuntar a net11.0 con el SDK correspondiente.
• El runtime ejecuta la aplicación. Si publicas en modo framework-dependent, el destino necesita un runtime compatible. En modo self-contained, publicas el runtime junto con la aplicación.
• ASP.NET Core, EF Core y .NET MAUI tienen paquetes, requisitos o herramientas propios. Revisa cada conjunto cuando actualices la plataforma.

Imagina que dotnet build funciona en tu equipo, pero el contenedor de producción falla al arrancar. El SDK de compilación puede ser correcto mientras la imagen final solo contiene el runtime de .NET 10. Comprueba ambas etapas de tu Dockerfile.

C# 15: novedades explicadas con ejemplos

Cada ejemplo va por separado. Puedes copiarlo en Program.cs con el proyecto de consola de la guía. Novedades oficiales de C# 15

Tipos unión para representar el resultado de un pedido

Si reservas una unidad, tu aplicación devuelve un número de pedido cuando lo consigue o la referencia del artículo que falta si se queda sin stock. Podrías devolver dos campos opcionales y obligar al siguiente método a interpretar todas las combinaciones. Con una unión declaras los dos resultados del dominio en el tipo de retorno.

ResultadoPedido resultado = Reservar(hayStock: false);

string mensaje = resultado switch
{
    PedidoAceptado pedido => $"Pedido {pedido.Numero} reservado.",
    SinExistencias falta => $"Sin existencias de {falta.Referencia}."
};

Console.WriteLine(mensaje);

static ResultadoPedido Reservar(bool hayStock)
{
    if (hayStock)
        return new PedidoAceptado(42);

    return new SinExistencias("C-17");
}

public record PedidoAceptado(int Numero);
public record SinExistencias(string Referencia);

public union ResultadoPedido(PedidoAceptado, SinExistencias);

Con false, el mensaje esperado es Sin existencias de C-17. Cambia el argumento a true para recorrer la otra rama. Si más adelante añades PagoRequerido a la unión, revisa los switch exhaustivos. El compilador puede señalar que falta una rama. En una API, decide por separado qué código HTTP y qué cuerpo corresponde a cada caso.

public closed record class EstadoEnvio;
public sealed record class EnPreparacion : EstadoEnvio;
public sealed record class Enviado(string Seguimiento) : EstadoEnvio;

HashSet<string> etiquetas =
    [with(StringComparer.OrdinalIgnoreCase), "API", "api", "Web"];

Console.WriteLine(etiquetas.Count); // 2

var agenda = new Agenda(new Dictionary<DateOnly, string>
{
    [new DateOnly(2026, 11, 10)] = "Revisar la API"
});

Console.WriteLine(agenda[new DateOnly(2026, 11, 10)]);

public record Agenda(IReadOnlyDictionary<DateOnly, string> Citas);

public static class AccesoAgenda
{
    extension(Agenda agenda)
    {
        public string? this[DateOnly fecha] =>
            agenda.Citas.TryGetValue(fecha, out var cita) ? cita : null;
    }
}

string[][] filas = [["A", ""], ["B", "Madrid"]];

fila:
foreach (var celdas in filas)
{
    foreach (var celda in celdas)
    {
        if (string.IsNullOrWhiteSpace(celda))
            continue fila;
    }

    Console.WriteLine(celdas[0]);
}

Runtime de .NET 11: qué puede mejorar y qué conviene medir

El runtime es el motor que pone en marcha tu programa. Dentro de él, el JIT prepara las instrucciones que entiende el procesador mientras la aplicación se ejecuta. En .NET 11 puede ahorrar trabajo en algunos bucles y llamadas. El efecto depende de qué parte de tu código se ejecuta con más frecuencia.

Runtime Async V2 cambia cómo se reanuda una tarea que estaba esperando, por ejemplo, una respuesta de red. Las bibliotecas del runtime ya lo usan. Para probarlo en tu código, la opción en vista previa es <Features>runtime-async=on</Features>.

Native AOT compila la aplicación por adelantado. En .NET 11 se optimizan algunas llamadas a través de interfaces. Si lo pruebas, revisa los avisos del compilador y comprueba que la aplicación publicada sigue leyendo y escribiendo los datos que esperas.

Requisitos de CPU. El mínimo para ejecutar .NET 11 en x64 pasa a x86-64-v2. Las imágenes ReadyToRun distribuidas en Linux y Windows pueden aprovechar un objetivo x86-64-v3. Windows en Arm64 requiere LSE. Prueba con la CPU que ve el proceso en producción. La configuración de una máquina virtual puede exponer menos instrucciones que el equipo anfitrión.

Para ver si te beneficia, compara el tiempo de arranque y la memoria de dos compilaciones Release con la misma carga y en la misma máquina. Si la mayor parte del tiempo se va en una consulta SQL, mide esa consulta por separado. Novedades del runtime · Análisis de rendimiento del equipo de .NET

SDK de .NET 11: proyectos pequeños, pruebas y contenedores

Qué cambió en el SDK entre RC3 y la versión final

Comparé los dos SDK oficiales para macOS Arm64. La versión final actualiza varias piezas que usas al compilar y restaurar paquetes. Estos son los números que muestran las herramientas:

El sufijo que informa NuGet pertenece a ese componente. La versión del SDK instalado se comprueba con dotnet --version. Microsoft también publicó correcciones de seguridad y de mantenimiento en .NET 11.0.0 y documenta que Visual Studio 2026 18.12.0 incluye el SDK estable. La versión de Visual Studio y la de MSBuild de la tabla identifican productos distintos. Notas de la versión final · Notas de RC3

Si venías de RC3, conserva net11.0 y revisa qué SDK fija global.json, qué imagen usa tu integración continua y qué versiones preliminares siguen en tus paquetes o workloads. Instalar el SDK estable no cambia por sí solo una referencia NuGet fijada en el proyecto. Guía de actualización de Microsoft

Qué trae el SDK de .NET 11 en el día a día

La CLI puede resolver algunas operaciones con un ejecutable compilado por adelantado y mantener un proceso de MSBuild listo para reutilizarlo en la siguiente compilación. Microsoft presenta estas mejoras como parte del ciclo de .NET 11. Anuncio de .NET 11

El instalador también mejora la deduplicación de archivos en macOS y Linux. Si mantienes imágenes o scripts que copian solo una parte de la instalación, conserva los enlaces simbólicos y comprueba el resultado en la imagen final. Novedades del SDK

Bibliotecas: FullJoin, JSON y conexiones

FullJoin en LINQ para conciliar dos listas

Un cruce normal conserva las coincidencias. Si estás conciliando movimientos del banco con tu libro contable, también quieres ver los que aparecen en un solo lado. FullJoin reúne los tres grupos. LeftJoin y RightJoin ya estaban disponibles en .NET 10.

Movimiento[] banco =
[
    new("A-01", 20m),
    new("A-02", 45m)
];

Movimiento[] libro =
[
    new("A-01", 20m),
    new("A-03", 12m)
];

foreach (var (enBanco, enLibro) in
    banco.FullJoin(libro, m => m.Id, m => m.Id))
{
    var id = enBanco?.Id ?? enLibro?.Id;
    var estado = (enBanco, enLibro) switch
    {
        (null, _) => "Solo en el libro",
        (_, null) => "Solo en el banco",
        _ => "En ambos"
    };

    Console.WriteLine($"{id}: {estado}");
}

record Movimiento(string Id, decimal Importe);

El resultado esperado contiene A-01 en ambos, A-02 solo en el banco y A-03 solo en el libro. Como Movimiento es una clase, la fila ausente aparece como null. Si hay claves repetidas, pueden salir varias combinaciones para una misma clave. Para comparar importes, añade esa comprobación en la rama de coincidencias.

JSON, archivos y red

• System.Text.Json amplía la compatibilidad con uniones de C# y F# y ofrece formas de producir JSON Lines. Este último formato usa un documento JSON por línea y resulta práctico para procesar registros de uno en uno. Si cambias el tipo de respuesta de una API, verifica el JSON real con los clientes que ya la consumen.
• Compresión y formatos binarios. Hay novedades en Zstandard y en el procesamiento de CBOR. Comprueba si las aplicaciones con las que intercambias datos admiten el formato elegido.
• HTTP, DNS y TLS. Aparecen más opciones para red y compresión de peticiones. Antes de comprimir un cuerpo HTTP, verifica qué admite el servidor y qué hacen los proxies intermedios.
• Criptografía. El trabajo en capacidades poscuánticas continúa. Para una integración real, confirma en la referencia de cada API su estado, los sistemas compatibles y la interoperabilidad con el otro extremo.
• Decimales. Ciertas conversiones pueden dar un resultado ligeramente distinto. En pagos, impuestos o facturación, prueba valores cercanos a los límites de redondeo con la regla que exige tu negocio.

Notas de bibliotecas de .NET 11 · Cambios de compatibilidad de .NET 11

ASP.NET Core 11: Minimal APIs, Blazor, SignalR y OpenAPI

Minimal APIs y OpenAPI: comprueba el contrato, además de compilar

Las Minimal APIs ganan opciones de validación asíncrona, integración con tipos unión y más control sobre los filtros cuando falla el binding, el paso que convierte la petición en los argumentos de tu método. Piensa en un formulario de alta. Si falla al interpretar una fecha, la respuesta de error importa tanto como el caso en que todo sale bien.

El generador integrado de OpenAPI pasa a usar 3.2 de forma predeterminada y actualiza su dependencia Microsoft.OpenApi. Con ello puede describir mejor flujos como Server-Sent Events, donde el servidor envía eventos sin cerrar la respuesta. Si generas un SDK cliente o tienes transformadores que editan el documento, revisa tres cosas:

1. Que tus transformadores compilen contra la versión nueva del modelo de objetos.
2. Que el cliente que genera código acepte el documento y que sus tipos sigan representando tus respuestas.
3. Que los estados HTTP, campos requeridos y tipos de contenido sean los mismos en el documento y en una petición real.

Si tu generador aún necesita 3.1, puedes pedirlo de forma explícita al configurar AddOpenApi. Esa opción controla el formato del documento. Revisa por separado los cambios de la biblioteca en tus transformadores.

Blazor: ¿qué ocurre en el navegador y qué ocurre en el servidor?

En SSR estático, el servidor genera el HTML. La validación en el navegador permite ver ciertos errores antes de enviar el formulario. El servidor sigue validando la petición. Puedes comprobarlo enviando un formulario inválido desde el navegador y luego con una petición directa.

Con Blazor interactivo de servidor, los componentes conservan estado y procesan la interacción en el servidor a través de una conexión. Los cambios relacionados con la pausa de circuitos interesan si una aplicación tiene muchas sesiones abiertas, pero conviene reproducir una desconexión con estado pendiente antes de depender de ellos.

En Blazor WebAssembly, el código se ejecuta en el navegador. Hay mejoras en el trabajo con workers y el servidor de desarrollo de aplicaciones WebAssembly independientes. Si usas una SPA independiente, comprueba una ruta profunda al recargar la página, además de la navegación desde el menú. En QuickGrid, prueba que ordenar, cambiar de página y volver atrás conserven el comportamiento esperado cuando la cuadrícula utiliza la URL.

Si tienes dos cuadrículas en la misma página, dales nombres distintos para sus parámetros de ordenación y paginación mediante QueryParameterNameOptions. Así un cambio en una cuadrícula puede actualizar su parte de la URL sin interferir con la otra.

SignalR: conexiones que duran más que una petición HTTP

Hay novedades para actualizar la autenticación y cancelar determinadas invocaciones. Si mantienes un panel en tiempo real, prueba qué ocurre cuando caduca una credencial con el panel abierto y qué trabajo se detiene al cancelar una operación.

Notas de ASP.NET Core 11 · Cambios incompatibles de ASP.NET Core

EF Core 11: consultas y almacenamiento según tu proveedor

EF Core traduce consultas de C# a operaciones de la base de datos. Antes de usar una novedad, comprueba que la admiten tu versión de EF Core, el paquete proveedor y el motor de base de datos.

Si tienes una entidad Documento con título, contenido y un vector, revisa qué propiedades trae la consulta de listado y qué necesita la búsqueda por similitud. La documentación describe escenarios donde los vectores de SQL Server se proyectan de forma explícita. Comprueba el SQL y el volumen de datos que realmente se transfieren.

Para migrar el modelo, genera el script SQL y léelo antes de aplicarlo a una copia de pruebas. Comprueba si cambia columnas, índices o tipos de datos. Si el despliegue es gradual, verifica que la versión anterior de la aplicación pueda seguir leyendo el esquema durante la transición.

Novedades oficiales de EF Core 11 · Proveedores de EF Core

.NET MAUI, Windows y F# 11

.NET MAUI 11 y aplicaciones móviles

CoreCLR pasa a ser el runtime predeterminado en las aplicaciones móviles dirigidas a .NET 11. Eso afecta a piezas que puedes tener fuera del código de la aplicación, como herramientas de diagnóstico, bibliotecas nativas o propiedades de compilación heredadas de Mono. Que el runtime sea CoreCLR tampoco implica que todas las plataformas puedan compilar con JIT. La modalidad de compilación depende del destino. Native AOT se evalúa por separado.

En Android, el nivel mínimo sube a API 24 y se retira el destino x86 de 32 bits. Si tu laboratorio solo usa un emulador antiguo, revisa su arquitectura. Si mantienes una aplicación con usuarios en dispositivos anteriores a API 24, comprueba cuántos quedarían fuera antes de decidir cuándo subir el mínimo.

En la interfaz hay mejoras en rutas Shell y enlaces compilados dentro de plantillas. Las nuevas plantillas de pruebas permiten ejecutar comprobaciones en el proceso de una app de prueba para Android, iOS y otros destinos. Prueba en dispositivo la navegación desde un enlace, el arranque en frío y una pantalla que dependa de una biblioteca nativa. .NET MAUI tiene un calendario de soporte propio. Novedades de .NET MAUI 11 · Compatibilidad de .NET 11 · Soporte de .NET MAUI

WinForms y WPF

WinForms incorpora trabajo en modo quiosco, presentación inicial de ventanas y optimizaciones de pintado. Para valorar el impacto, abre tu formulario más pesado con el escalado y el número de controles que usas en producción. Observa cuándo aparece la ventana y cuándo está lista para interactuar.

WPF publica correcciones concretas. Si migras una aplicación de escritorio, revisa los controles que usas, el escalado de pantalla y la navegación con teclado. Prueba en el Windows de destino. WinForms y WPF siguen siendo tecnologías de escritorio para Windows. WinForms en .NET 11 · WPF en .NET 11

F# 11

F# 11 amplía la construcción de registros reutilizando campos de otros registros. Piensa en un registro de lectura y otro de edición con campos comunes. La ampliación facilita trasladar esos campos y especificar los que cambian. También hay mejoras de compilación y de la biblioteca básica para trabajo asíncrono y código destinado a AOT. Si compartes modelos de F# con consumidores C#, prueba la API pública y el JSON que cruza esa frontera. Novedades de F# 11

Cambios incompatibles de .NET 11 que merece la pena probar

Compilar detecta referencias que ya no existen. Los cambios de comportamiento suelen aparecer al enviar una petición, leer un archivo o ejecutar el servicio en otro equipo.

La lista oficial sigue evolucionando. Filtra por lo que usa tu aplicación y convierte cada caso relevante en una prueba que puedas repetir. Compatibilidad de .NET 11 · Compatibilidad de ASP.NET Core 11

Cómo instalar .NET 11 y migrar desde .NET 10

1. Instala el SDK que corresponde a tu sistema

En la página oficial, selecciona el SDK para tu sistema operativo y arquitectura. Para escribir y compilar el ejemplo necesitas el SDK. Para ejecutar una aplicación ya publicada en modo dependiente del framework, instala el runtime que requiera esa aplicación. Si es una aplicación web ASP.NET Core, revisa que el entorno incluya ASP.NET Core Runtime.

Desde la carpeta de tu repositorio, consulta qué se ha instalado y qué selecciona la CLI:

dotnet --list-sdks
dotnet --list-runtimes
dotnet --version
dotnet --info

Si acabas de instalar el SDK del lanzamiento, dotnet --version debería mostrar 11.0.100 en un proyecto que lo seleccione. Si tienes un global.json, puede seguir seleccionando .NET 10 o RC3 aunque el SDK estable ya esté instalado. Comprueba el resultado dentro del repositorio y en CI. Descarga de .NET 11 · Referencia de global.json

2. Ejecuta un primer ejemplo fuera de tu solución

Con un SDK de .NET 11 activo, crea una consola:

dotnet new console --framework net11.0 --output prueba-net11
cd prueba-net11
dotnet run

La plantilla debe arrancar y mostrar su saludo. Sustituye Program.cs por el ejemplo de la unión del pedido o por el de FullJoin. Ejecuta otra vez dotnet run y compara la salida con la esperada. Usa un archivo nuevo para cada ejercicio o reemplaza todo su contenido entre pruebas.

3. Toma una referencia de tu versión actual

Antes de actualizar, ejecuta las pruebas y guarda el contrato OpenAPI, el JSON de un par de endpoints representativos, el tiempo de arranque y el artefacto que despliegas. Revisa los proveedores de EF, los paquetes de terceros y los workloads de MAUI si los usas. Una referencia de antes permite distinguir una regresión nueva de una que ya estaba en el proyecto.

4. Cambia el TFM y alinea las herramientas

En el proyecto que corresponda, actualiza el destino:

<PropertyGroup>
  <TargetFramework>net11.0</TargetFramework>
</PropertyGroup>

Si publicas una biblioteca para varios marcos, revisa TargetFrameworks y conserva los destinos que tus consumidores necesiten. Si la solución fija el SDK, actualiza global.json con la versión real que hayas instalado y probado. Revisa Directory.Packages.props si gestionas versiones de forma centralizada. Actualiza de forma coordinada los paquetes de EF Core y el proveedor compatible.

5. Compila, prueba y ejecuta el artefacto final

dotnet restore
dotnet build -c Release --no-restore
dotnet test -c Release --no-build

Ejecuta estas órdenes desde la solución o el proyecto adecuado. Después publica tu aplicación con su perfil habitual y arranca ese resultado. En Docker, verifica las imágenes base de las etapas de SDK y runtime, la arquitectura y las comprobaciones de salud. En una API, prueba los casos correctos y los fallos de autenticación, validación y conexión a datos.

6. Despliega primero en pruebas y prepara la vuelta atrás

Decide con antelación qué resultado aceptas y qué resultado obliga a volver al artefacto anterior. Puede ser que el cliente de facturación falle, que una comprobación de salud se quede bloqueada o que el p95 supere el margen que acordaste. Si hay cambios de base de datos, comprueba que la vuelta atrás del binario sigue siendo viable con el esquema ya desplegado.

Si ya estás en .NET 10 y solo te interesa una optimización, prueba primero el cambio de plataforma sin reescribir código. Cuando las pruebas pasen, añade las novedades de C# o EF Core que resuelvan una necesidad concreta. Así puedes atribuir un cambio de comportamiento al paso que lo introdujo. Guía de migración de ASP.NET Core de 10 a 11

Preguntas frecuentes sobre .NET 11

¿.NET 11 es LTS?

Es STS, con soporte hasta el 14 de noviembre de 2028. Si tu equipo exige LTS para producción, .NET 10 cumple ese requisito. Política de soporte

¿Puedo tener .NET 10 y .NET 11 instalados a la vez?

Sí. Puedes ver ambos SDK con dotnet --list-sdks y seleccionar el adecuado por repositorio con global.json. Repite la comprobación en CI y dentro del contenedor donde compilas. Documentación de global.json

¿Puedo usar C# 15 con .NET 10?

La combinación soportada por defecto para C# 15 es .NET 11. Algunas capacidades del compilador tienen reglas específicas de compatibilidad. Para una solución que mantienes en producción, sigue la combinación recomendada para su TFM y consulta los requisitos de la característica concreta. Versiones de lenguaje de C#

¿Migrar a .NET 11 cambia la base de datos?

Actualizar el TFM por sí solo no aplica un script de base de datos. Una actualización del proveedor o de EF puede cambiar el SQL generado o la forma de interpretar un modelo. Si tu aplicación aplica migraciones al arrancar, comprueba ese paso explícitamente antes del despliegue. Aplicar migraciones de EF Core

¿Necesito Aspire, Azure o Copilot para probarlo?

Puedes instalar el SDK y compilar el ejemplo de consola de forma local. Aspire, los servicios de Azure y Copilot tienen sus propias versiones y requisitos. Si ya los usas, comprueba por separado su compatibilidad con el SDK. Descarga del SDK · Documentación de Aspire

Más ejemplos en el blog

• Integrar Redsys en .NET con tarjeta y Bizum
• Introducción a Semantic Kernel con C#
• Cómo crear y probar una imagen Docker desde cero