Qué cambia realmente en .NET 11 para los mantenedores

Espacio de trabajo tecnológico editorial que representa las pruebas de actualización a .NET 11 para mantenedores de software de código abierto

.NET 11, publicado el 10 de noviembre, se entiende mejor como una actualización de plataforma que como una única función destacada. Para quien mantiene un proyecto de código abierto, la pregunta útil es si el SDK, el compilador, el runtime, las bibliotecas, las herramientas de compilación y la ruta de despliegue funcionan de forma conjunta en el flujo de trabajo real del proyecto. La versión combina cambios de C# 15 con un inicio más rápido de la línea de comandos, un servidor de MSBuild que permanece activo, mejoras del runtime, nuevas API de bibliotecas y avances continuos en Native AOT. Por eso, la primera evaluación se parece menos a leer una lista de funciones y más a seguir el recorrido desde una copia limpia del repositorio hasta un artefacto probado. (Anuncio de .NET 11)

Los cambios del lenguaje son importantes, pero no exigen automáticamente una reescritura. C# 15 añade tipos unión y jerarquías cerradas, lo que permite que un valor represente uno de un conjunto declarado de casos y que el compilador compruebe el tratamiento de esas alternativas. Esto puede aclarar los estados acotados en bases de código que actualmente dependen de convenciones, patrones de herencia o discriminadores mantenidos manualmente. La decisión de usar la función sigue dependiendo de la política de versión del lenguaje del proyecto, los frameworks de destino, la superficie de la API pública y las expectativas de quienes contribuyen. En una biblioteca consolidada, una sintaxis más reciente puede mejorar el código interno, pero también generar dudas de compatibilidad para los consumidores y para los proyectos que compilan contra más de un destino.

Varios cambios son relevantes porque mejoran el conjunto de herramientas que rodea al código de la aplicación, en lugar de modificarlo directamente. El SDK de .NET 11 habilita de forma predeterminada un host de CLI basado en Native AOT, de modo que comandos como las consultas de ayuda y versión pueden evitar el inicio de la CLI administrada. El servidor de MSBuild también permanece activo entre invocaciones de la CLI, lo que reduce el trabajo repetido de arranque. Estas mejoras pueden beneficiar la iteración local y la automatización aunque las aplicaciones de un repositorio sigan dirigidas a un framework anterior. Por tanto, los mantenedores deben separar la instalación y el uso del SDK de .NET 11 del cambio del framework de destino del proyecto: lo primero es una decisión sobre las herramientas, mientras que lo segundo modifica la superficie del runtime y la compatibilidad. (Detalles del SDK y el runtime)

Las incorporaciones a las bibliotecas muestran por qué importa esa distinción. LINQ incorpora FullJoin, junto con sobrecargas relacionadas para combinaciones externas y retornos de tuplas, mientras que System.IO.Compression añade API para Zstandard y más compatibilidad con compresión basada en spans. Estos cambios pueden sustituir ayudantes personalizados, dependencias adicionales o búferes intermedios cuando el código lo permita. Sin embargo, no están disponibles automáticamente para todos los destinos de un paquete multitarget. El mantenedor quizá tenga que aislar la implementación más reciente, conservar una ruta anterior o posponer la adopción hasta que la matriz de soporte del proyecto haga que el cambio merezca la pena. Las notas de la versión también documentan cambios de comportamiento, así que el código que procese datos comprimidos, conversiones numéricas u otras operaciones de bajo nivel merece pruebas de regresión específicas. (Cambios en las bibliotecas de .NET 11)

Async del runtime es otro ejemplo de una oportunidad que conviene tratar como una decisión comprobable. En .NET 11, la suspensión y reanudación asíncronas pueden trasladarse al runtime en lugar de depender de máquinas de estados generadas por el compilador, con pilas de llamadas activas más claras para perfiladores y depuradores. La función sigue en versión preliminar, y habilitarla para el código de la aplicación es algo distinto de compilar con ella las bibliotecas del runtime. Esa diferencia es importante para los mantenedores: una nueva capacidad del runtime no equivale a un requisito de migración predeterminado. Antes de convertirla en parte de una compilación compatible, hay que comprobar las dependencias, el diagnóstico y el comportamiento específico del proyecto.

Por tanto, la base práctica es modesta y concreta. Hay que compilar el repositorio con el nuevo SDK, ejecutar sus pruebas habituales y sus comandos de desarrollo, y medir las operaciones que realmente notan quienes contribuyen y quienes usan el proyecto. Conviene registrar qué mejoras llegan solo con el SDK, cuáles requieren cambiar el destino y cuáles dependen de decisiones de la aplicación o de publicación, como Native AOT. Este enfoque convierte .NET 11 de una decisión basada en el número de versión en un experimento de compatibilidad acotado y deja para la siguiente etapa de la revisión las preguntas más visibles del flujo de trabajo: las pruebas, los contenedores y la estrategia de soporte.

El flujo de trabajo del desarrollador es la superficie de actualización más fácil de probar

Para un mantenedor de código abierto, la forma más rápida de evaluar .NET 11 es probar el ciclo diario del repositorio: restaurar, compilar, ejecutar pruebas, empaquetar y ejecutar repetidamente un comando representativo. El anuncio de la versión describe mejoras en el SDK, las herramientas de pruebas, las aplicaciones basadas en archivos, los flujos de trabajo móviles y la publicación de contenedores. Estos cambios pueden comprobarse sin cambiar de destino de inmediato una aplicación de producción, pero su valor depende de los comandos y la configuración reales del proyecto. Microsoft también advierte que los resultados de rendimiento varían según la carga de trabajo y el modo de publicación, por lo que las afirmaciones sobre rendimiento deben tratarse como hipótesis que hay que verificar, no como garantías universales. (anuncio de .NET 11)

El cambio más visible del SDK es un host de CLI con Native AOT. Comandos como las consultas de ayuda y de versión pueden evitar iniciar la CLI administrada, y los lanzamientos de herramientas pueden usar la misma ruta con menor sobrecarga. Esto importa sobre todo en comandos de corta duración, donde el arranque del proceso representa una parte significativa del tiempo total. Mide por separado las ejecuciones en frío y en caliente, y después compara una secuencia de los comandos que realmente utilizan los colaboradores. Una compilación grande puede seguir estando dominada por la compilación y el trabajo con dependencias, mientras que una utilidad pequeña o una invocación repetida de pruebas puede mostrar una diferencia más clara.

.NET 11 también mantiene caliente el servidor de MSBuild entre invocaciones de la CLI de forma predeterminada. Eso convierte el trabajo incremental en un caso de prueba útil: ejecuta dos veces una compilación o unas pruebas sin cambios, modifica un archivo fuente pequeño y repite la comparación. El primer comando establece el estado; los siguientes pueden beneficiarse de que el servidor ya esté disponible. No des por sentado que un ejecutor de CI se comportará como una estación de trabajo de desarrollador, especialmente cuando los trabajos utilizan entornos nuevos. Registra la versión del SDK, el tipo de ejecutor, las condiciones de caché y los argumentos del comando para que una mejora medida pueda reproducirse.

Las pruebas reciben controles más explícitos. En los proyectos que usan Microsoft.Testing.Platform, dotnet test añade tiempos de espera a nivel de ejecución, límites de fallos, informes de progreso más claros y directorios de resultados por módulo. Los modificadores pertinentes dependen de la plataforma de pruebas, por lo que no son intercambiables con las opciones de línea de comandos de VSTest. Verifica el descubrimiento de pruebas, los códigos de salida, los registros, los archivos de resultados y el comportamiento ante fallos con el mismo adaptador, marco de destino y configuración de CI que utiliza el repositorio. Una ejecución local correcta no demuestra que otro ejecutor o script envolvente interprete las opciones del mismo modo.

Una matriz de flujo de trabajo compacta mantiene el experimento centrado:

Flujo de trabajo Comprobación Evidencia que se debe conservar
Arranque de la CLI Comandos repetidos en frío y en caliente Tiempos, SDK, shell y condiciones de caché
Compilaciones incrementales Repetición sin cambios y edición de un archivo fuente pequeño Salida de compilación y tiempo transcurrido
Ejecución de pruebas Selección, tiempos de espera, límites de fallos y artefactos Ejecutor, registros, código de salida y rutas de resultados
Destinos móviles Selección de la carga de trabajo y ejecución orientada al dispositivo Descubrimiento, implementación e informes de fallos
Publicación de contenedores Compilaciones repetidas con entradas fijas Resumen de imagen, resultado del arranque y archivos publicados

Las aplicaciones basadas en archivos añaden otro experimento de flujo de trabajo de bajo riesgo. La directiva #:include permite que una aplicación basada en archivos crezca a través de varios archivos de código fuente, lo que puede facilitar el mantenimiento de ejemplos compactos, scripts y pequeñas herramientas de línea de comandos. El beneficio debe valorarse frente a las convenciones existentes del repositorio: verifica las referencias a paquetes, el comportamiento del marco de destino, la salida generada y el comando exacto de CI. Un punto de entrada más sencillo resulta útil cuando reduce la ceremonia; no es motivo para reestructurar una solución consolidada de varios proyectos sin pruebas que lo justifiquen.

Las herramientas de filtrado de soluciones también son prácticas de probar. Si el proyecto utiliza archivos .slnf, ejecuta los comandos documentados de restauración, compilación y pruebas mediante los mismos scripts y puntos de entrada de CI que usan los colaboradores. Comprueba qué proyectos se restauran, compilan y prueban realmente, en lugar de basarte solo en un código de salida correcto. Un filtro que funciona de forma interactiva pero que un script envolvente o un trabajo automatizado ignora puede crear una falsa sensación de cobertura.

Los destinos de pruebas móviles importan principalmente a los repositorios que utilizan las cargas de trabajo correspondientes. Pruébalos en un entorno controlado y confirma la selección del destino, el descubrimiento, la implementación, la salida y la notificación de errores. En otros proyectos, esto forma parte de la revisión de cargas de trabajo, no de la decisión central de actualización. La publicación de contenedores merece el mismo tratamiento acotado: los resúmenes reproducibles de imagen solo son significativos cuando están fijados la revisión del código fuente, el SDK, la imagen base, los argumentos de compilación, el modo de publicación y las demás entradas. Después de comparar los resúmenes, ejecuta la imagen y comprueba el inicio, la configuración, las dependencias nativas y los archivos publicados.

La conclusión práctica para esta etapa es clara: separa los valores predeterminados del comportamiento opcional, y separa las mejoras del SDK de los requisitos del ejecutor de pruebas, las cargas de trabajo, el formato del proyecto o la configuración del contenedor. Una rama pequeña, con los comandos y las salidas registrados, mostrará si .NET 11 mejora el flujo de trabajo de este repositorio y si alguna ventaja aparente se mantiene en los entornos donde realmente trabajan los mantenedores y la CI.

Las comprobaciones de compatibilidad, soporte y seguridad deben preceder a la adopción

La primera pregunta sobre la adopción no es si .NET 11 contiene cambios útiles. Es si su modelo de soporte y su perfil de compatibilidad encajan con el horizonte de mantenimiento del proyecto. .NET 11 es una versión de soporte estándar (STS), con una ventana de soporte de dos años. Eso la convierte en una opción relevante para proyectos que quieren la plataforma actual y están preparados para seguir un ciclo de actualización más corto, pero no implica el mismo compromiso que elegir la rama de soporte a largo plazo. .NET 10 sigue siendo la alternativa LTS para los mantenedores que priorizan un periodo más prolongado de estabilidad frente al acceso a la línea de versiones más reciente.

Esa distinción debe establecerse antes de cambiar el marco de destino de un proyecto. Una biblioteca de código abierto puede ser capaz de admitir varias versiones de .NET a la vez, mientras que una aplicación o herramienta con un entorno de implementación estrictamente controlado puede tener más libertad para cambiar de destino. Por tanto, la decisión relevante no es simplemente «actualizar o quedarse atrás», sino qué ventana de soporte se ajusta al proceso de lanzamiento, la base de usuarios y la capacidad del proyecto para probar cada runtime compatible. El calendario de versiones también hace urgente la planificación de las ramas antiguas: .NET 8 y .NET 9 llegan al final del soporte el 10 de noviembre de 2026. Los mantenedores que sigan en cualquiera de esas versiones necesitan un plan de migración explícito, en lugar de suponer que una actualización futura puede posponerse indefinidamente.

El trabajo de compatibilidad debería comenzar con la documentación oficial de cambios incompatibles de .NET 11 y continuar por el grafo de dependencias propio del proyecto. Cambiar el destino de la aplicación es solo una parte del cambio. El runtime, el SDK, las versiones de los paquetes, la infraestructura de pruebas, las cargas de trabajo y las imágenes de implementación deben coincidir con la línea de versiones prevista. Una compilación que funciona localmente aún puede ocultar una discrepancia en un ejecutor de pruebas, una carga de trabajo de plataforma o un paquete que depende de un comportamiento del runtime fuera de la cobertura de pruebas habitual del proyecto. En los repositorios de código abierto, este es también el momento de revisar las matrices de integración continua y las instrucciones para colaboradores: la actualización no está completa si la rama principal solo funciona en el equipo del mantenedor.

Los requisitos mínimos de hardware se han actualizado para .NET 11, por lo que la compatibilidad no se limita al código fuente ni a las referencias de paquetes. Antes de considerar rutinaria la actualización, hay que comprobar los agentes de compilación, los equipos de desarrollo y los destinos de implementación compatibles frente a la nueva base mínima. Esto resulta especialmente importante para los proyectos que publican binarios, ofrecen distribuciones autocontenidas o documentan un amplio abanico de entornos operativos. Una actualización del runtime puede ser técnicamente correcta y, aun así, reducir la audiencia si determinadas combinaciones de hardware o sistemas operativos antiguos dejan de ser viables.

Los modos de implementación requieren una revisión independiente. Native AOT y el recorte pueden mejorar la estructura o las características de arranque de una aplicación, pero imponen restricciones que no se aplican a todas las implementaciones administradas habituales. El código que depende de la carga dinámica, de ciertos patrones de reflexión o de API sin la información de análisis necesaria puede requerir trabajo adicional, y una compilación normal correcta no demuestra que una publicación con AOT o recortada se comporte igual. Por ello, los mantenedores deberían probar cada modo de implementación que realmente prometen a los usuarios, en lugar de tratar la compatibilidad con Native AOT como una propiedad automática de una aplicación .NET 11.

La misma cautela se aplica a las API descritas como experimentales, incluidas las relacionadas con criptografía y búsqueda vectorial. El carácter experimental indica que conviene aislar esas llamadas detrás de una interfaz estrecha, documentar el riesgo y evitar que se conviertan accidentalmente en la base de una API pública ampliamente utilizada. Pueden resultar valiosas para la evaluación, pero su adopción debe contemplar la posibilidad de que una superficie experimental necesite revisiones antes de poder tratarse como un contrato estable de compatibilidad.

Por último, las correcciones de seguridad de la versión 11.0.0 deben formar parte de la evaluación de la actualización, no de una lista independiente que se complete después de mover el código. Los responsables del proyecto deberían revisar los detalles de la versión, confirmar que los artefactos de SDK y runtime seleccionados incluyen las correcciones previstas y comprobar cómo llegan esos artefactos a los procesos de compilación y creación de contenedores. Las cachés de paquetes, las imágenes base fijadas y las reglas de actualización automática pueden hacer que un repositorio use un nivel de parche distinto del que sus responsables creen haber probado. Por tanto, la pregunta de seguridad práctica es si toda la ruta de compilación y despliegue consume la versión corregida, no simplemente si el archivo del proyecto menciona .NET 11.

Un criterio razonable consiste en registrar los marcos de destino compatibles, los sistemas operativos, las suposiciones sobre el hardware, los modos de despliegue y las versiones de las dependencias antes de cambiar el destino. Después, hay que ejecutar la aplicación representativa y la suite de pruebas contra esa matriz declarada, prestando especial atención al arranque, a los fallos que solo aparecen con trimming o AOT y a cualquier comportamiento cubierto por los cambios incompatibles documentados. Si el proyecto no puede reproducir estas comprobaciones, la vía LTS de .NET 10 puede ser una opción más responsable para la estabilidad en producción, mientras .NET 11 queda como una rama controlada para el trabajo de compatibilidad y su adopción futura.

Quién debería probar .NET 11 ahora y cómo organizar la evaluación

.NET 11 es un candidato razonable para una evaluación de código abierto cuando el proyecto puede mantener una rama de compatibilidad controlada y tiene un motivo concreto para medir la nueva plataforma. Esto se aplica especialmente a repositorios nuevos, herramientas para desarrolladores, proyectos con muchas pruebas y cargas de trabajo en las que el arranque de la CLI, Native AOT, la reproducibilidad de los contenedores o el comportamiento del runtime forman parte del perfil práctico del producto. La cuestión útil no es si la versión contiene funciones atractivas consideradas de forma aislada, sino si las rutas propias de compilación, pruebas, empaquetado y despliegue mejoran sin añadir una carga de soporte o dependencias que supere esas ventajas.

Empieza con una rama o una muestra representativa, en lugar de cambiar de una vez el destino predeterminado para todos los colaboradores. Fija en global.json el SDK utilizado por el experimento para que las máquinas locales y la CI no seleccionen silenciosamente SDK diferentes. Registra los sistemas operativos, las arquitecturas, las cargas de trabajo, los ejecutores de pruebas, las imágenes base de los contenedores y los modos de despliegue incluidos en la comparación. Actualizar el SDK y cambiar el destino de una aplicación son decisiones relacionadas, pero separables: un repositorio puede validar primero la cadena de herramientas de .NET 11 y mantener los proyectos de producción en su marco de destino actual hasta completar las pruebas de compatibilidad.

La primera pasada debe ser observable y repetible. Ejecuta las mismas compilaciones limpias e incrementales, los mismos comandos de CLI repetidos, las mismas suites de pruebas, los mismos pasos de empaquetado y los mismos escenarios representativos de la aplicación tanto sobre la base existente como sobre .NET 11. Compara el tiempo de arranque, el uso de memoria, el rendimiento cuando sea relevante para el proyecto, el tamaño de la imagen del contenedor y la fiabilidad de las pruebas. En las herramientas de línea de comandos, mide las rutas de invocación en frío y repetidas. En los servicios, incluye el comportamiento durante el arranque y en régimen estable. En las bibliotecas, da más peso a la duración de la compilación, los ejemplos consumidores, los marcos de destino compatibles y la cobertura de pruebas que a un único microbenchmark.

Trata los resultados de las pruebas de rendimiento como evidencia del proyecto, no como promesas universales. Una ruta más rápida del SDK o del runtime puede quedar oculta por un ejecutor de pruebas lento, un proceso externo, una dependencia de red o una carga de trabajo poco representativa. A la inversa, una mejora modesta puede ser valiosa cuando aparece en cada comando local o trabajo de CI. Mantén la comparación reproducible usando los mismos datos de entrada, configuración, variables de entorno, clase de hardware y flujo de trabajo de contenedores, y conserva suficientes registros para distinguir un cambio de plataforma de la variación normal.

Las pruebas deben incluir rutas que una compilación predeterminada correcta puede pasar por alto. Ejecuta la matriz completa de pruebas, incluidas las configuraciones que usan Microsoft.Testing.Platform u opciones específicas del ejecutor, y verifica el filtrado, los diagnósticos, la cobertura, los reintentos y la publicación de resultados. Si el repositorio utiliza aplicaciones basadas en archivos, filtros de soluciones, destinos de prueba móviles, cargas de trabajo o lógica MSBuild personalizada, prueba directamente esos puntos de entrada. Quienes usen contenedores deben comparar el flujo real de creación de imágenes y verificar las referencias y los resúmenes criptográficos seleccionados, porque la reproducibilidad forma parte de la cadena de suministro de software.

Antes de cambiar el destino, revisa los paquetes directos y transitivos, los analizadores, los generadores de código fuente, los adaptadores de prueba, las cargas de trabajo del SDK y los scripts que dan por supuesto un comportamiento concreto del framework o del SDK. Confirma que las imágenes de CI, los entornos de alojamiento y las combinaciones de sistemas operativos coincidan con la política de soporte del proyecto. Si el proyecto utiliza trimming o Native AOT, prueba el artefacto publicado en sí: el código que depende mucho de la reflexión, la carga dinámica, las bibliotecas no compatibles y las suposiciones sobre el entorno de ejecución pueden hacer que una compilación correcta sea una señal incompleta. Son comprobaciones de compatibilidad específicas del despliegue, no beneficios automáticos de instalar un SDK más reciente.

El umbral de decisión debe reflejar la realidad del mantenimiento. Un proyecto nuevo o centrado en herramientas puede probar .NET 11 pronto si su grafo de dependencias es pequeño, los entornos compatibles están definidos explícitamente y las mejoras medidas en el flujo de trabajo son relevantes. Una aplicación de producción consolidada puede preferir .NET 10 cuando la duración del soporte y la previsibilidad operativa importan más que adoptar la versión STS más reciente. Es una decisión de ingeniería, no un rechazo de .NET 11. Documenta el SDK probado, el framework de destino, el modo de despliegue, las incompatibilidades conocidas y las condiciones que activarían una nueva prueba más adelante.

Antes de fusionar un cambio de destino, revisa la documentación sobre cambios importantes de .NET 11 y clasifica cada hallazgo como aplicable, aplazado o no relevante. Comprueba la alineación entre el runtime y los paquetes, las correcciones de seguridad de la versión .NET 11.0.0 y cualquier API experimental de criptografía o búsqueda vectorial antes de convertirlas en parte de un contrato público estable. Ten en cuenta también el soporte: .NET 11 ofrece soporte estándar durante dos años, mientras que .NET 10 sigue siendo la alternativa LTS. Los proyectos que todavía dependan de .NET 8 o .NET 9 deben incluir su estado de soporte en el plan de migración, ya que ambas versiones dejarán de recibir soporte el 10 de noviembre de 2026.

Un resultado gradual es más útil que un veredicto binario sobre la actualización: fija la versión y compila, ejecuta la matriz completa de pruebas y empaquetado, compara los artefactos de despliegue y el comportamiento medido, y después revisa la compatibilidad, las dependencias, las cargas de trabajo y las obligaciones de soporte. Si las pruebas son positivas, cambia el destino de la parte práctica más pequeña y amplía la cobertura antes de modificar el valor predeterminado de todo el proyecto. Si son mixtas, conservar el destino actual y usar el SDK más reciente cuando corresponda permite aprender sin imponer una migración sin terminar. Para los mantenedores, esa es la verdadera prueba de .NET 11: determinar si sus cambios en las herramientas y el runtime resisten la superficie de compatibilidad del repositorio y justifican el intercambio en materia de soporte.