Préambule
La .NET Conf 2026, tenue du 10 au 13 novembre, accompagnait le lancement de .NET 11. Après avoir écouté plusieurs sessions, je retiens surtout la continuité entre les travaux sur la plateforme, les outils de développement et l’intégration de l’IA.
Compiler plus rapidement, réduire la mémoire consommée par les outils, mieux diagnostiquer une application et faciliter sa modernisation participent au même objectif. Ils raccourcissent le chemin entre une intention et un changement que l’on peut vérifier, puis livrer.
J’ai déjà présenté plusieurs nouveautés du langage, du runtime et des bibliothèques dans mon article consacré à .NET 11, rédigé à partir de la RC 2. Ce retour sur la conférence le complète en regroupant les sujets par thème et en mettant l’accent sur les gains possibles pour nos équipes et nos applications.
Il s’agit d’une vue d’ensemble des sessions que j’ai suivies. Je ne vais donc pas approfondir chaque fonctionnalité ici. D’autres articles suivront pour explorer certains sujets avec des exemples, des mesures et leurs implications en entreprise.
La disponibilité de .NET 11 doit aussi être distinguée du statut des outils et fonctionnalités présentés. Certaines capacités restent en préversion ou expérimentales, tandis que d’autres appartiennent à la feuille de route.
.NET 11 : mieux exprimer les intentions et réduire le coût d’exécution
Du modèle C# au contrat HTTP
Les nouveautés de C# 15 comprennent notamment les unions, les hiérarchies fermées, les arguments des expressions de collection, les indexeurs d’extension et les instructions break et continue avec étiquette.
Les unions et les hiérarchies fermées sont particulièrement intéressantes pour les applications métier. Elles rendent les résultats possibles d’une opération plus explicites et permettent au compilateur de mieux vérifier leur traitement. Une évolution du modèle peut ainsi faire ressortir les endroits qui doivent être adaptés.
Ce travail se prolonge dans System.Text.Json, puis dans ASP.NET Core et la description OpenAPI des API. On peut conserver davantage d’information entre le modèle applicatif et le contrat exposé aux consommateurs.
Le gain dépasse la réduction du code répétitif. Des états mieux définis facilitent la compréhension, la revue et l’évolution du logiciel. La forme du contrat JSON reste cependant une décision à prendre, notamment lorsque plusieurs cas d’une union produisent des objets difficiles à distinguer.
Runtime Async et calcul numérique
Runtime Async déplace une partie de la gestion des suspensions et des reprises vers le runtime. La syntaxe async et await demeure familière, tandis que le moteur dispose davantage d’information pour optimiser l’exécution.
Les gains visés concernent certaines allocations, le coût des chaînes d’appels et le traitement des exceptions. Les piles d’appels observées dans les outils de diagnostic deviennent aussi plus lisibles. Pour un service fortement asynchrone, cela peut améliorer à la fois son efficacité et notre capacité à comprendre son comportement.
Runtime Async reste en préversion dans .NET 11 et son activation pour le code applicatif est explicite. Je le mesurerais séparément de la migration générale afin d’identifier ce qu’il apporte aux parcours réellement utilisés.
Les évolutions du calcul numérique élargissent cette réflexion aux types numériques, à Complex<T> et aux opérations sur les tenseurs. Ces travaux intéressent notamment les traitements scientifiques, les transformations de données et certaines charges liées à l’IA. Le choix de la précision et la justesse des résultats font partie de l’évaluation de performance.
Une chaîne de développement plus rapide
Réduire les coûts répétés de la CLI et de MSBuild
Le travail sur la CLI et Native AOT réduit le coût de démarrage de certaines opérations. L’hôte natif conserve un chemin d’exécution managé pour les commandes qui en ont besoin.
L’intérêt apparaît lorsqu’on enchaîne les commandes. Une économie sur chaque lancement s’accumule dans un script, un pipeline ou une boucle de travail pilotée par un agent. La réduction de la taille de certaines distributions du SDK contribue également à alléger leur acquisition.
Le mode multithread de MSBuild poursuit le même objectif en réduisant le travail dupliqué entre les processus de compilation. Le mode présenté s’active avec -mt et partage davantage l’infrastructure du moteur, tout en conservant des mécanismes d’isolation pour les tâches qui en ont besoin.
Les compilations incrémentales sont une cible importante, puisqu’elles reviennent constamment dans le travail quotidien. Pour une grande solution, le bénéfice peut se traduire par moins d’attente avant de relancer un test ou de vérifier une modification. Les tâches MSBuild personnalisées doivent faire partie des essais de compatibilité avant une adoption à grande échelle.
C# Dev Kit revoit ses fondations
La refonte de C# Dev Kit 11 dans Visual Studio Code est l’une des démonstrations les plus marquantes côté outillage. Elle combine une architecture plus compacte, la réutilisation d’informations sur les projets et une meilleure gestion des compilations incrémentales.
Les mesures publiées par l’équipe sur la solution Aspire, composée de 407 projets, donnent une idée du potentiel.
| Mesure sur la solution Aspire | C# Dev Kit 3.3 | C# Dev Kit 11.0 |
|---|---|---|
| Compilation incrémentale après modification d’un fichier C# | 36,1 s | 2,1 s |
| Mémoire des processus du serveur C# Dev Kit | 2 072 Mo | 316 Mo |
Ces résultats correspondent aux scénarios mesurés. La comparaison mémoire exclut notamment Visual Studio Code et le service de langage Roslyn. Elle ne décrit donc pas la consommation totale du poste.
Pour une équipe, l’intérêt est de retrouver plus rapidement une solution exploitable et de conserver de la mémoire pour les applications, les conteneurs et les tests. Les mêmes économies deviennent particulièrement utiles lorsque plusieurs espaces de travail ou agents coexistent sur une machine.
Des petits outils C# plus faciles à faire évoluer
Les applications basées sur des fichiers progressent avec #:include, qui permet de répartir le code dans plusieurs fichiers, ainsi qu’avec une meilleure intégration aux commandes habituelles, dont dotnet format.
Ce format devient plus pratique pour un diagnostic reproductible, une transformation de données ou une automatisation interne. On peut commencer simplement et faire évoluer l’outil lorsque son usage le justifie.
Le gestionnaire dotnetup, présenté dans la keynote, vise de son côté à simplifier l’installation et la mise à jour des SDK et runtimes dans le compte utilisateur. Il est encore en préversion publique.
Visual Studio et Copilot : mieux accompagner le travail quotidien
Navigation, documentation et Git
Les évolutions de Visual Studio touchent plusieurs gestes du quotidien.
- Une vue du système de fichiers pour accéder aux éléments qui ne sont pas représentés dans la solution.
- Une meilleure expérience Markdown, avec aperçu et insertion de liens ou d’images par glisser-déposer.
- Une navigation améliorée entre HTML et CSS.
- Une option pour arrêter la compilation dès le premier échec.
- Un affichage plus précis des différences entre chaînes lors de certains échecs de tests.
Sur une grande solution, arrêter tôt une compilation vouée à l’échec peut éviter une attente inutile. Pour la documentation, mieux prendre en charge Markdown facilite l’entretien des README, des consignes du dépôt et des instructions destinées aux agents.
L’intégration de Git dans Visual Studio complète ce parcours avec les worktrees, les sous-modules, la consultation des commits et des pull requests. Les worktrees permettent notamment de garder plusieurs branches accessibles dans des répertoires distincts, ce qui facilite une revue ou un travail parallèle sans interrompre la tâche principale.
Un moteur commun pour Copilot et davantage de choix de modèles
La session The State of AI in Visual Studio explique l’évolution du moteur qui organise le contexte, les outils et l’exécution des agents. Visual Studio 18.12 adopte une fondation commune avec le Copilot SDK.
Cela rend les améliorations du moteur plus facilement réutilisables entre les environnements. La qualité d’un agent dépend aussi de ce qu’il peut observer, des outils qu’il peut appeler et du retour qu’il reçoit après chaque action.
La disponibilité générale de Bring Your Own Model dans Visual Studio 18.12 ouvre aussi la porte à différents fournisseurs, à des modèles hébergés par l’organisation et à des modèles locaux exposés par une API compatible.
Pour une entreprise, ce choix peut aider à adapter l’expérience aux contraintes d’accès, de confidentialité et de coût. Il faut toutefois vérifier les capacités du modèle retenu et le parcours réel des données. Héberger un modèle localement ne suffit pas à encadrer les autres outils utilisés par l’agent.
Donner aux agents des connaissances adaptées à .NET
Dans Beyond Autocomplete, les skills servent à fournir des procédures et des connaissances ciblées aux agents. Le dépôt dotnet/skills rassemble ces ressources, et un tableau de bord d’évaluation suit leur effet sur les résultats.
La possibilité de distribuer des skills avec un paquet NuGet est également présentée dans la conférence. Une bibliothèque peut ainsi fournir des indications d’utilisation proches de la version réellement consommée.
J’y vois un moyen de réduire les suggestions fondées sur des API anciennes et de rendre certaines pratiques plus cohérentes entre les développeurs. Ces connaissances complètent les conventions du dépôt et les validations exécutables de l’équipe.
Tests et modernisation : produire des changements que l’on peut vérifier
La qualité des assertions prend une place importante dans les échanges sur les tests. Un test peut réussir tout en vérifiant très peu de choses sur le comportement attendu. Avec la génération de code, cette distinction devient essentielle.
Les agents de test peuvent aider à repérer des scénarios manquants ou à examiner les assertions. La valeur se mesure alors à la capacité de détecter une régression métier. Par exemple, un test de validation devrait vérifier la règle enfreinte et le résultat attendu, au-delà de la simple présence d’un objet de réponse.
Microsoft.Testing.Platform poursuit aussi l’amélioration de l’exécution et du diagnostic des tests. La démonstration utilise MSTest, mais la plateforme prend en charge plusieurs frameworks. Son adoption doit tenir compte du framework, des extensions et des commandes déjà utilisés dans les pipelines.
GitHub Copilot modernization applique cette logique aux applications existantes. L’agent examine les dépendances, produit une évaluation, prépare un plan et accompagne les modifications ainsi que leur validation.
Le premier gain peut arriver avant la migration elle-même. Une évaluation structurée aide à rendre visibles les obstacles et à préparer le découpage du travail. L’automatisation réduit ensuite une partie des modifications répétitives, tandis que l’équipe conserve la responsabilité des choix d’architecture et de la validation fonctionnelle.
La modernisation concerne aussi les applications de bureau. La session consacrée à Windows Forms présente un mode de styles visuels modernes et une meilleure prise en compte des paramètres d’accessibilité. Ces capacités permettent d’envisager une évolution progressive de l’interface en conservant les contrôles et les processus métier qui ont encore de la valeur.
ASP.NET Core et Blazor : des contrats plus riches et des sessions plus résilientes
Les évolutions d’ASP.NET Core et de Blazor rapprochent plusieurs améliorations autour des API et de l’expérience utilisateur.
La validation asynchrone permet aux mécanismes pris en charge dans les Minimal APIs et les formulaires Blazor d’attendre une opération d’entrée-sortie. OpenAPI 3.2 devient la version générée par défaut, avec une description plus riche de certains contrats. Il reste possible de sélectionner une version antérieure lorsqu’un générateur de clients ne prend pas encore en charge la nouvelle.
La protection contre les requêtes intersites forgées, ou CSRF, évolue également en s’appuyant sur les métadonnées envoyées par les navigateurs modernes. L’objectif est de réduire le travail lié aux jetons pour les points de terminaison couverts, notamment les formulaires Blazor. Cette protection doit être évaluée avec les clients de l’application et sa configuration de sécurité.
Du côté de Blazor Server, plusieurs capacités améliorent l’utilisation des ressources et la gestion des sessions.
CacheViewpermet de mettre en cache le rendu d’une partie de page en SSR statique.- La mise en pause des circuits peut libérer des ressources lorsqu’une session interactive devient inactive.
- Le rafraîchissement de l’authentification sur les connexions longues permet de faire évoluer l’identité sans imposer systématiquement une reconnexion.
Pour une application de gestion ouverte toute la journée, ces mécanismes peuvent réduire la mémoire immobilisée par des onglets inactifs et améliorer la continuité d’utilisation. La pause automatique exige une configuration explicite. Il faut aussi choisir l’état à conserver et protéger les données saisies avec une stratégie de sauvegarde adaptée.
EF Core 11 : des requêtes plus efficaces et une recherche plus riche
EF Core 11 progresse à la fois dans l’expression des requêtes, leur traduction et l’outillage.
Les améliorations de traduction LINQ, l’élimination de certaines jointures inutiles et le meilleur support des opérations JSON peuvent réduire le travail demandé à la base de données. Les types complexes et les colonnes JSON deviennent également utilisables avec davantage de stratégies de mapping, notamment les hiérarchies TPT et TPC.
Les gains restent liés aux requêtes exécutées et au fournisseur utilisé. Pour une migration, je regarderais d’abord les parcours fréquents, les plans d’exécution et les volumes traités. Une meilleure traduction peut simplifier le SQL produit, tandis que la qualité des projections et des index reste déterminante.
La recherche vectorielle ouvre aussi des possibilités pour retrouver des documents ou des éléments proches sur le plan sémantique. Les index vectoriels et la recherche approximative pour SQL Server restent toutefois expérimentaux, comme le précise la documentation des nouveautés EF Core 11. Leur intérêt dépend des capacités du serveur et du compromis entre rapidité et qualité des résultats.
Du côté des outils, .config/dotnet-ef.json permet de partager des paramètres récurrents, comme le projet de données et le projet de démarrage. Cela simplifie les commandes et réduit les écarts entre les habitudes locales des membres de l’équipe.
Un point mérite enfin une vérification lors d’une migration. Le fournisseur SQL Server adopte par défaut le niveau de compatibilité 160, associé à SQL Server 2022. Une application qui utilise une base de données plus ancienne ou configurée avec un niveau inférieur doit choisir un niveau approprié dans EF Core, puis valider les requêtes générées.
Intégrer l’IA dans les applications .NET
Des fondations communes pour les modèles et les données
La pile IA de .NET s’appuie notamment sur trois fondations complémentaires.
Microsoft.Extensions.AIfournit des abstractions pour accéder aux modèles.Microsoft.Extensions.VectorDatafacilite l’intégration des magasins de données vectorielles.Microsoft.Extensions.DataIngestionaccompagne la préparation et l’ingestion de données.
Ces bibliothèques permettent de composer des fonctionnalités d’IA avec des pratiques familières comme l’injection de dépendances et l’observabilité. Microsoft Agent Framework ajoute des capacités d’orchestration d’agents et de workflows.
Pour une application métier, les usages peuvent être ciblés. Améliorer une recherche, extraire les informations d’un document ou préparer une synthèse peut déjà faire gagner du temps. On peut introduire ces capacités progressivement, avec des critères de qualité propres au besoin.
Relier les outils, l’agent et l’utilisateur
Le MCP C# SDK fournit un protocole commun pour exposer des outils et les rendre accessibles aux agents. Une capacité métier peut ainsi être utilisée par plusieurs clients compatibles, avec une intégration partagée.
La session Building the future of agentic UI with Blazor traite une autre partie du problème. AG-UI organise les échanges entre l’agent et l’interface, notamment les événements, les demandes d’approbation et l’état partagé.
L’utilisateur peut décrire un objectif, suivre les actions proposées, examiner le résultat et continuer à le modifier dans l’interface habituelle. Cela peut faciliter l’utilisation d’applications riches, où une tâche exige aujourd’hui plusieurs recherches et manipulations.
Les composants Blazor pour ces interfaces restent expérimentaux. Les autorisations et les validations métier doivent être appliquées par les services appelés, et les actions importantes doivent rester compréhensibles pour la personne qui les déclenche.
Aspire et Azure : faciliter l’exécution et le diagnostic
Aspire rassemble les éléments de l’application
Aspire poursuit son évolution comme outil de composition, d’exécution, d’observation et de déploiement d’applications comprenant plusieurs composants.
Les sujets présentés incluent l’intégration de Blazor WebAssembly, les migrations EF Core, le tableau de bord et une nouvelle expérience de ressources pour les projets .NET. Cette dernière vise notamment à coordonner davantage la restauration et la compilation. Certains éléments sont présentés comme des travaux pour la prochaine version majeure.
Pour une solution composée d’une API, d’une interface, d’une base de données et de traitements en arrière-plan, le gain est de disposer d’une description commune et d’un point d’observation cohérent. Cela facilite l’arrivée d’un développeur et raccourcit la recherche d’une erreur entre plusieurs services.
Les travaux sur l’outillage Aspire illustrent aussi l’utilisation de Native AOT pour alléger le démarrage et la distribution de ses composants. Les agents bénéficient du même environnement observable pour lancer l’application et vérifier les effets d’une modification.
Azure fournit des environnements d’exécution adaptés aux agents
La session Azure’s new lineup for .NET developers présente des démonstrations autour des sandboxes Azure Container Apps, des hosted skills avec Azure Functions, d’AI Gateway et d’Azure SRE Agent.
Les sandboxes Azure Container Apps offrent des environnements isolés dont on contrôle le cycle de vie. Elles sont pertinentes lorsqu’un outil doit exécuter du code ou traiter un document dans un espace distinct du poste de développement ou du service principal.
Les démonstrations autour de Functions et de l’exploitation montrent également comment intégrer l’IA à des traitements déclenchés par des événements et à l’analyse d’incidents. Les gains possibles concernent le traitement de cas moins structurés et la réduction du temps nécessaire pour réunir les éléments d’un diagnostic. Ils dépendent des données disponibles, des permissions accordées et des limites imposées aux actions.
Sécurité : accompagner l’automatisation à chaque niveau
L’accélération du développement touche aussi la sélection et la publication des dépendances, comme le souligne la session sur la sécurité de NuGet à l’ère de l’IA.
Le délai minimal avant d’adopter une version nouvellement publiée ajoute une protection contre certaines attaques à propagation rapide. Il complète l’analyse des vulnérabilités et la revue des dépendances. La session annonce aussi davantage de contrôle sur les scripts NuGet exécutés automatiquement dans Visual Studio, avec des changements prévus dans des versions ultérieures du client.
Pour les équipes qui publient sur nuget.org, Trusted Publishing réduit la gestion de clés persistantes en s’appuyant sur l’identité du pipeline et des identifiants temporaires. C’est un gain opérationnel autant qu’une réduction de l’exposition des secrets.
La session sur la protection du poste face aux agents de développement prolonge cette réflexion. L’isolation de l’exécution, les règles d’accès réseau et la gestion des identifiants doivent être pensées ensemble. Un agent doit pouvoir réaliser sa tâche avec un périmètre de travail et des accès définis.
Au niveau de la plateforme, les nouvelles règles de sécurité mémoire, encore en préversion, cherchent à rendre les obligations des API unsafe plus explicites pour leurs appelants. La session 2 Secure 2 Curmudgeonly rappelle aussi l’importance des correctifs dans la durée.
Enfin, la cryptographie post-quantique continue de progresser, notamment avec Composite ML-KEM et HPKE. Plusieurs API restent expérimentales et dépendent de la stabilisation des standards. Pour les organisations, un premier travail utile consiste à connaître les usages cryptographiques existants et leur capacité à évoluer.
Conclusion
Ce que je retiens de cette .NET Conf 2026, c’est l’attention portée à l’ensemble du travail logiciel. Les modèles deviennent plus expressifs, les outils réduisent leur consommation de ressources, les applications gagnent des capacités supplémentaires et les agents s’intègrent davantage à la livraison.
Les bénéfices se mesureront dans nos contextes. Moins de temps pour compiler et diagnostiquer, moins de mémoire mobilisée, des contrats plus faciles à maintenir et des migrations mieux préparées sont des résultats concrets à rechercher.
Pour une équipe, je commencerais par un périmètre connu. Mesurer une grande solution avec le nouvel outillage, évaluer une application à moderniser ou tester une fonctionnalité d’IA sur un besoin métier précis permet de décider à partir de résultats observables.
Je reviendrai dans de prochains articles sur plusieurs de ces sujets, notamment Runtime Async, les performances de compilation, les skills .NET et l’intégration d’agents dans nos applications. Ce panorama donne les directions. La suite sera l’occasion de regarder comment les appliquer.