La version la plus récente de .NET est .NET 10, publiée récemment en novembre 2025. Il s'agit d'une version à support à long terme (LTS) qui devrait recevoir des mises à jour jusqu'en novembre 2028. Selon Microsoft, .NET 10 est la version la plus productive, moderne, sécurisée, intelligente et performante de .NET à ce jour. Elle est le fruit d'une nouvelle année d'efforts de la part de milliers de développeurs à travers le monde.La plateforme .NET (prononcée « dot net » ; anciennement nommée .NET Core) est un framework logiciel gratuit et open source pour les systèmes d'exploitation Windows, Linux et macOS. Il s'agit d'un successeur multiplateforme du .NET Framework. Le projet est principalement développé par des employés de Microsoft par l'intermédiaire de la .NET Foundation et est aujourd'hui publié sous licence MIT.
La version la plus récente de .NET est .NET 10, publiée récemment en novembre 2025. Il s'agit d'une version à support à long terme (LTS) qui devrait recevoir des mises à jour jusqu'en novembre 2028. Selon Microsoft, .NET 10 est la version la plus productive, moderne, sécurisée, intelligente et performante de .NET à ce jour. Elle est le fruit d'une nouvelle année d'efforts de la part de milliers de développeurs à travers le monde. Cette version comprend des milliers d'améliorations en termes de performances, de sécurité et de fonctionnalités sur l'ensemble de la pile .NET, des langages et outils de développement aux charges de travail, vous permettant de créer à partir d'une plateforme unifiée et d'intégrer facilement l'IA à vos applications.
Pour l'annonce, Microsoft déclare : ".NET 10 n'aurait pas pu voir le jour sans notre formidable communauté. Merci à tous ceux qui ont contribué à cette version en signalant des problèmes, en soumettant des demandes d'extraction, en révisant le code et en donnant leur avis. L'écosystème .NET continue de prospérer avec plus de 478 000 packages sur NuGet qui ont été téléchargés plus de 800 milliards de fois. Des milliers d'entreprises dans le monde entier, notamment H&R Block, Geocaching, Chipotle, Fidelity et bien d'autres, ainsi que des produits et services ici chez Microsoft tels que Xbox, Bing, Microsoft Graph, Azure Cosmos DB, Microsoft Exchange, Microsoft Teams et Microsoft Copilot, font confiance à .NET pour créer leurs applications les plus critiques."
Voici les principales améliorations :
- Améliorations du compilateur JIT : meilleure intégration, dévirtualisation des méthodes et génération de code améliorée pour les arguments de structure
- Accélération matérielle : prise en charge d'AVX10.2 pour les puces Intel de pointe, Arm64 SVE pour une vectorisation avancée avec des améliorations de la barrière d'écriture Arm64 réduisant les temps de pause GC de 8 à 20 %
- Améliorations NativeAOT : applications compilées à l'avance plus petites et plus rapides
- Optimisations du runtime : l'inversion de boucle améliorée et les stratégies d'allocation de pile offrent des gains de performances mesurables
C# 14 et F# 10
C# 14 et F# 10 apportent de puissantes améliorations au langage qui rendent votre code plus concis et plus expressif. C# reste l'un des langages de programmation les plus populaires au monde, se classant parmi les 5 premiers dans le rapport GitHub Octoverse 2025.
Points forts de C# 14
Les propriétés soutenues par des champs simplifient les déclarations de propriétés en éliminant le besoin de champs de soutien explicites. Le compilateur génère automatiquement le champ de support, ce qui rend votre code plus propre et plus facile à maintenir :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 | // Automatic backing field with custom logic public string Name { get => field; set => field = value?.Trim() ?? string.Empty; } |
Les propriétés et méthodes d'extension permettent d'ajouter des membres à des types qui ne vous appartiennent pas, y compris des interfaces et des membres statiques, ce qui rend les types d'extension beaucoup plus puissants. Vous pouvez désormais créer des propriétés d'extension qui fonctionnent de manière transparente avec les types de votre base de code :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 | // Extension properties for any type static class ListExtensions { extension(List<int> @this) { public int Sum => @this.Aggregate(0, (a, b) => a + b); } } |
Fonctionnalités supplémentaires de C# 14 :
- Conversions Span<T> de première classe : prise en charge implicite des conversions pour des opérations span hautes performances.
- Affectation conditionnelle null : opérateur ?.= pour un code d'affectation null-safe plus propre.
- Modificateurs de paramètres dans les lambdas : utilisez les paramètres ref, in ou out sans types explicites.
- Extensions d'expression de collection : .._expression_ vers params et syntaxe de propagation [.._expression_].
- Résolution de surcharge améliorée : attribut [OverloadResolutionPriority] pour une meilleure sélection des méthodes.
- Propriétés et constructeurs partiels : complétez l'histoire des membres partiels avec des propriétés, des constructeurs et des événements.
- Implémentations d'interface ref struct : meilleures performances avec des modèles sans allocation.
Points forts de F# 10
F# 10 est une version améliorée axée sur la clarté, la cohérence et les performances, avec des améliorations significatives pour le code quotidien.
Améliorations du langage :
- Suppression des avertissements dans un périmètre donné : utilisez #warnon associé à #nowarn pour activer ou désactiver les avertissements dans des sections de code spécifiques, ce qui vous permet de contrôler précisément les diagnostics du compilateur.
- Modificateurs d'accès sur les accesseurs de propriétés automatiques : créez des propriétés lisibles publiquement mais modifiables en privé sans champs de support verbeux (member val Balance = 0m with public get, private set).
- Paramètres facultatifs ValueOption : appliquez l'attribut [<Struct>] aux paramètres facultatifs pour utiliser ValueOption<'T> basé sur une structure au lieu d'une option allouée dans le tas, éliminant ainsi les allocations dans le code critique pour les performances.
- Prise en charge des appels en queue dans les expressions de calcul : les constructeurs peuvent désormais opter pour des optimisations d'appels en queue avec les méthodes ReturnFromFinal et YieldFromFinal.
- Liaisons typées sans parenthèses : écrivez des annotations de type naturelles telles que let! x: int = fetchA() dans les expressions de calcul sans parenthèses.
Bibliothèque principale et performances :
- and! dans les expressions de tâche : attendez simultanément plusieurs tâches avec une syntaxe idiomatique : let! a = fetchA() and! b = fetchB().
- Cache de subsomption de types : compilation plus rapide et réactivité de l'EDI grâce à des vérifications mémorisées des relations entre les types.
- Aperçu de la compilation parallèle : vérification des types basée sur des graphes, génération parallèle de code IL et optimisation parallèle activées par défaut avec LangVersion=Preview- Meilleur rognage par défaut : les substitutions générées automatiquement suppriment les ressources de métadonnées F# pour des applications publiées plus petites
Bibliothèques .NET – API sécurisées et modernes
Les bibliothèques .NET 10 apportent des mises à jour importantes en matière de chiffrement, de mise en réseau, de sérialisation et plus encore, rendant les applications plus sûres et plus efficaces.
Chiffrement post-quantique
.NET 10 étend la prise en charge du chiffrement post-quantique (PQC) :
- Prise en charge de Windows CNG : utilisez les algorithmes ML-DSA et ML-KEM avec les API de cryptographie Windows.
- ML-DSA amélioré : variante HashML-DSA pour des caractéristiques de sécurité améliorées.
- ML-DSA composite : approches hybrides combinant des algorithmes traditionnels et résistants aux quantums pour une défense en profondeur.
Réseau amélioré
Les améliorations apportées au réseau rendent les applications plus rapides et plus performantes :
- WebSocketStream : API WebSocket simplifiée, plus facile à utiliser et plus efficace.
- TLS 1.3 sur macOS : prise en charge TLS moderne sur toutes les principales plateformes.
- Prise en charge des groupes de processus Windows : meilleure gestion des processus sous Windows.
- Optimisations des performances : réduction des allocations et amélioration du débit sur HTTP, les sockets et les WebSockets.
Améliorations supplémentaires de la bibliothèque
- Améliorations JSON : interdiction des propriétés en double pour une désérialisation plus sûre, paramètres de sérialisation améliorés, prise en charge de PipeReader pour les scénarios hautes performances.
- Mises à jour cryptographiques : AES KeyWrap avec remplissage pour un encapsulage sécurisé des clés dans les scénarios de conformité.
- Mises à jour système : diagnostics améliorés, meilleure interopérabilité avec le code natif, collections améliorées.
Aspire : orchestrez sans effort les interfaces utilisateur, les API, les conteneurs et les bases de données
Aspire facilite la création d'applications distribuées observables et prêtes à être mises en production grâce à la télémétrie intégrée, la découverte de services et les intégrations cloud. Aspire 13 est livré avec .NET 10 et apporte des améliorations majeures pour le développement polyglotte, les workflows modernes et le déploiement en entreprise.
Points forts :
- Expérience de développement moderne : améliorations de l'interface CLI, prise en charge d'AppHost à fichier unique pour une organisation rationalisée des projets et une intégration plus rapide grâce à des modèles simplifiés.
- Création et déploiement transparents : prise en charge intégrée des sites de fichiers statiques pour les applications frontales, parallélisation robuste du déploiement pour des versions plus rapides et workflows de conteneurs prêts pour la production
- Infrastructure prête pour l'entreprise : chaînes de connexion flexibles et gestion de la confiance des certificats qui fonctionne de manière cohérente dans toutes vos applications
Fonctionnalités supplémentaires :
- SDK AppHost simplifié : définissez Aspire.AppHost.Sdk comme seul SDK du projet
- Prise en charge d'AddCSharpApp : nouvelles alternatives CSharpAppResource et AddCSharpApp à AddProject
- Sécurité renforcée : paramètres codés pour les données de configuration sensibles, confiance des certificats de ressources personnalisable
- Améliorations du tableau de bord : configuration des revendications OpenID Connect pour une authentification flexible
Collaboration avec d'autres plateformes :
Lorsque vos applications .NET doivent s'intégrer à des services écrits en Python, JavaScript ou d'autres langages, Aspire 13 rend cette opération transparente. Vous pouvez orchestrer l'ensemble de votre application distribuée à partir de votre .NET AppHost grâce à une prise en charge complète du débogage, des fichiers Dockerfiles générés automatiquement et des modèles de variables d'environnement unifiés sur toutes les plateformes.
Intelligence artificielle – Des intégrations simples aux systèmes multi-agents
.NET facilite la création d'applications basées sur l'IA, des intégrations simples aux systèmes multi-agents complexes. Des entreprises telles que H&R Block, Blip et KPMG utilisent .NET pour leurs solutions d'IA, et le nouveau Microsoft Copilot est développé avec .NET.
Microsoft Agent Framework – Créez des systèmes multi-agents intelligents
Microsoft Agent Framework simplifie la création de systèmes d'IA intelligents et agents en combinant le meilleur de Semantic Kernel et d'AutoGen dans une expérience unifiée. Que vous créiez un seul agent IA ou que vous orchestriez plusieurs agents travaillant ensemble, le framework vous fournit les modèles et l'infrastructure dont vous avez besoin.
Créez des workflows IA sophistiqués avec un minimum de code :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | // Create agents with minimal code AIAgent writer = new ChatClientAgent( chatClient, new ChatClientAgentOptions { Name = "Writer", Instructions = "Write engaging, creative stories." }); // Orchestrate in workflows AIAgent editor = new ChatClientAgent(chatClient, /* ... */); Workflow workflow = AgentWorkflowBuilder.BuildSequential(writer, editor); AIAgent workflowAgent = await workflow.AsAgentAsync(); |
Le framework prend en charge plusieurs modèles de flux de travail pour répondre aux besoins de votre application :
- Flux de travail séquentiels : les agents s'exécutent dans un ordre défini, la sortie de chaque agent alimentant le suivant
- Flux de travail simultanés : plusieurs agents travaillent en parallèle pour un traitement plus rapide
- Workflows de transfert : les agents se transmettent dynamiquement le contrôle en fonction du contexte et des exigences.
- Chat de groupe : les agents collaborent par le biais de conversations pour résoudre des problèmes complexes.
- Magentic : un gestionnaire dédié coordonne une équipe d'agents spécialisés.
Intégrez des outils de manière transparente, qu'il s'agisse de simples fonctions C# ou de serveurs MCP (Model Context Protocol) complets. Le framework est prêt à être utilisé en production et prend en charge l'injection de dépendances, les pipelines middleware et OpenTelemetry pour l'observabilité.
Vous pouvez rapidement commencer à créer des agents hébergés sur serveur avec Microsoft Agent Framework et ASP.NET Core à l'aide du nouveau modèle AI Agent Web API (aiagent-webapi) disponible dans le package de modèles Microsoft.Agents.AI.ProjectTemplates.
| Code C# : | Sélectionner tout |
1 2 3 4 | dotnet new install Microsoft.Agents.AI.ProjectTemplates dotnet new aiagent-webapi -o MyAIAgentWebApi cd MyAIAgentWebApi dotnet run |
Cela crée un projet ASP.NET Core Web API qui héberge vos agents et les expose en tant que points de terminaison HTTP standard. Il inclut l'interface utilisateur Microsoft Agent Framework Dev, qui fournit un harnais de test basé sur le Web pour valider et visualiser les agents et les flux de travail via une interface interactive.
Microsoft Agent Framework prend désormais en charge le protocole AG-UI pour la création d'interfaces utilisateur riches pour les agents. AG-UI est un protocole léger basé sur les événements pour les interactions entre les humains et les agents qui facilite la création d'interfaces utilisateur en streaming, l'appel d'outils front-end, la gestion des états partagés et d'autres expériences d'interface utilisateur pour les agents. Découvrez divers scénarios compatibles avec AG-UI grâce à Microsoft Agent Framework à l'aide de l'application exemple AG-UI Dojo.
Utilisez le nouveau package Microsoft.Agents.AI.Hosting.AGUI.AspNetCore pour mapper facilement les points de terminaison AG-UI pour vos agents.
| Code C# : | Sélectionner tout |
1 2 | // Map an AG-UI endpoint for the publisher agent at /publisher/ag-ui app.MapAGUI("publisher/ag-ui", publisherAgent) |
Vous pouvez ensuite utiliser les frameworks clients AG-UI existants, tels que CopilotKit, pour créer rapidement des expériences utilisateur riches pour vos agents. Vous pouvez également utiliser le nouveau client de chat .NET AG-UI du package Microsoft.Agents.AI.AGUI pour créer vos propres expériences d'interface utilisateur à l'aide de votre framework d'interface utilisateur .NET préféré, tel que .NET MAUI ou Blazor.
| Code C# : | Sélectionner tout |
IChatClient aguiChatClient = new AGUIChatClient(httpClient, "publisher/ag-ui);
Microsoft.Extensions.AI – Blocs de construction unifiés pour les applications d'IA
Microsoft.Extensions.AI et Microsoft.Extensions.VectorData fournissent des abstractions unifiées pour intégrer des services d'IA dans vos applications. L'interface IChatClient fonctionne avec n'importe quel fournisseur (OpenAI, Azure OpenAI, GitHub Models, Ollama) via une API cohérente, ce qui facilite le changement de fournisseur ou la prise en charge de plusieurs backends sans avoir à réécrire votre code.
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 | // Use any AI provider with the same interface IChatClient chatClient = new AzureOpenAIClient(endpoint, credential) .AsChatClient("gpt-4o"); var response = await chatClient.CompleteAsync("Explain quantum computing"); Console.WriteLine(response.Message); |
Les abstractions unifiées prennent en charge :
- Flexibilité des fournisseurs : passez d'un fournisseur d'IA à un autre sans modifier le code.
- Pipeline middleware : ajoutez la mise en cache, la journalisation ou un comportement personnalisé à n'importe quel appel IA.
- Injection de dépendances : enregistrez les services IA à l'aide de modèles .NET familiers.
- Télémétrie : prise en charge OpenTelemetry intégrée pour surveiller l'utilisation de l'IA.
- Données vectorielles : abstractions unifiées pour les bases de données vectorielles et la recherche sémantique.
Ces composants fonctionnent de manière transparente avec Microsoft Agent Framework, Semantic Kernel et vos propres implémentations IA.
Protocole de contexte de modèle (MCP) – Étendez les agents IA avec des outils et des services
.NET fournit une prise en charge MCP de premier ordre pour étendre les agents IA avec des outils et des services externes. Le protocole de contexte de modèle permet aux agents IA d'accéder aux sources de données, aux API et aux outils de manière standardisée, rendant vos agents plus performants et polyvalents.
Installez les modèles .NET AI et utilisez le modèle de serveur MCP pour créer et publier rapidement des serveurs MCP :
| Code C# : | Sélectionner tout |
1 2 | dotnet new install Microsoft.Extensions.AI.Templates dotnet new mcpserver -n MyMcpServer |
Une fois créé, publiez votre serveur MCP sur NuGet pour faciliter son utilisation au sein de votre organisation ou de la communauté .NET au sens large. Le SDK C# MCP fait l'objet de mises à jour régulières afin d'implémenter les dernières mises à jour du protocole, garantissant ainsi la compatibilité avec l'écosystème MCP en pleine expansion.
MCP permet aux agents IA :
- d'accéder aux bases de données et aux API en toute sécurité ;
- d'exécuter des commandes et des workflows ;
- de lire et de modifier des fichiers ;
- de s'intégrer aux systèmes d'entreprise ;
- d'utiliser des outils et des services spécialisés.
En standardisant la manière dont les agents IA interagissent avec les ressources externes, MCP facilite la création, le partage et la composition de capacités IA dans l'écosystème .NET.
ASP.NET Core – Applications Web et API sécurisées et hautes performances
ASP.NET Core dans .NET 10 comprend tout ce dont vous avez besoin pour créer des applications Web et des API sécurisées et hautes performances. Cette version met l'accent sur la sécurité, l'observabilité et les diagnostics, les performances et la productivité des développeurs, en fournissant des outils plus puissants pour créer des expériences Web modernes.
Les principales améliorations de cette version sont les suivantes :
- Expulsion automatique du pool de mémoire : dans les applications à exécution longue, les pools de mémoire peuvent parfois conserver de la mémoire qui n'est plus nécessaire. .NET 10 introduit l'expulsion automatique des pools de mémoire, ce qui permet de réduire l'empreinte mémoire de vos applications en libérant la mémoire inactive vers le système.
- Prise en charge de l'authentification Web (clé d'accès) : ASP.NET Core Identity inclut désormais la prise en charge des clés d'accès, qui sont basées sur les normes WebAuthn et FIDO2. Cela vous permet de créer des expériences d'authentification plus sécurisées et sans mot de passe. Le modèle de projet Blazor Web App inclut une prise en charge prête à l'emploi de la gestion des clés d'accès et de la connexion.
- Améliorations natives AOT : le modèle webapiaot inclut désormais la prise en charge OpenAPI par défaut, et grâce à une nouvelle validation compatible AOT, il est plus facile de créer des API documentées et compilées à l'avance. Vous pouvez désactiver cette fonctionnalité à l'aide du drapeau --no-openapi.
Blazor – Développement web productif basé sur des composants
Blazor continue d'évoluer en tant que framework productif pour la création d'interfaces utilisateur web basées sur des composants avec C#. .NET 10 apporte des améliorations significatives en termes de performances, de gestion de l'état et d'expérience globale des développeurs.
Persistance de l'état des composants :
.NET 10 introduit des améliorations significatives dans la gestion de l'état de Blazor, le rendant plus robuste et plus facile à utiliser, en particulier dans les scénarios côté serveur.
- Persistance déclarative de l'état : la persistance de l'état pendant le pré-rendu est désormais beaucoup plus simple. Utilisez l'attribut [PersistentState] pour marquer de manière déclarative l'état qui doit être conservé.
- Persistance de l'état des circuits : les circuits Blazor sont désormais plus résistants aux interruptions réseau. L'état des composants est automatiquement conservé avant qu'un circuit ne soit évacué après une déconnexion prolongée, afin que les utilisateurs ne perdent pas leur travail.
- Mise en pause et reprise des circuits : de nouvelles API permettant de « mettre en pause » et de « reprendre » les circuits améliorent l'évolutivité du serveur en libérant des ressources pour les clients inactifs.
Performances et fiabilité :
- Scripts de framework optimisés : les scripts du framework Blazor sont désormais fournis sous forme d'actifs web statiques précompressés et identifiés par empreinte digitale, ce qui améliore les performances de chargement et garantit une mise en cache correcte.
- Préchargement WebAssembly : afin d'améliorer les temps de chargement initiaux, les applications Web Blazor préchargent désormais automatiquement les ressources du framework à l'aide d'en-têtes Link. Les applications WebAssembly autonomes bénéficient également du téléchargement de ressources à haute priorité.
- Diffusion en continu des réponses par défaut : les réponses HttpClient sont désormais diffusées en continu par défaut dans les applications WebAssembly Blazor, ce qui peut améliorer les performances et réduire l'utilisation de la mémoire lors du traitement de réponses volumineuses.
Formulaires et validation :
- Amélioration de la validation des formulaires : les capacités de validation des formulaires de Blazor ont été considérablement améliorées. Vous pouvez désormais valider automatiquement les objets imbriqués et les éléments de collection à l'aide d'un nouveau système basé sur un générateur de source qui est performant et compatible avec AOT.
- Nouveau composant InputHidden : un nouveau composant permettant de rendre les champs de formulaire masqués est désormais disponible.
Expérience développeur :
- Tests automatisés du navigateur : WebApplicationFactory prend désormais en charge les tests de bout en bout avec des outils d'automatisation du navigateur tels que Playwright, ce qui facilite l'écriture de tests UI automatisés pour vos applications web.
- Améliorations de l'interopérabilité JavaScript : l'interopérabilité avec JavaScript est désormais plus puissante. Vous pouvez créer des instances d'objets JavaScript, appeler leurs constructeurs et lire ou modifier directement leurs propriétés à l'aide d'API synchrones et asynchrones.
- Amélioration du traitement des erreurs « Not Found » : Blazor offre une meilleure expérience pour le traitement des erreurs 404. Vous pouvez désormais spécifier une page « Not Found » dédiée dans le composant Router, et la nouvelle méthode NavigationManager.NotFound() facilite le déclenchement des réponses « Not Found » à partir du code pendant le rendu côté serveur ou le rendu interactif.
- Améliorations de QuickGrid : le composant QuickGrid inclut désormais un paramètre RowClass, qui vous permet d'appliquer des classes CSS personnalisées aux lignes en fonction de leurs données. Vous pouvez également gérer explicitement le masquage de l'interface utilisateur des options de colonne.
Créez des API rapides et modernes
ASP.NET Core est un excellent choix pour créer des API rapides et modernes. .NET 10 offre une meilleure conformité aux normes, une validation plus puissante et une expérience développeur améliorée.
Améliorations OpenAPI :
- Prise en charge d'OpenAPI 3.1 par défaut : ASP.NET Core génère désormais des documents OpenAPI 3.1, qui incluent la prise en charge de la dernière version préliminaire du schéma JSON. Cela améliore la représentation des types, par exemple en utilisant un tableau pour les types nullables au lieu d'une propriété personnalisée.
- Intégration des commentaires XML : le générateur de source OpenAPI utilise désormais automatiquement vos commentaires XML C# pour remplir les descriptions, les résumés et d'autres champs de documentation dans le document OpenAPI généré.
- Documents OpenAPI YAML : vous pouvez désormais fournir des documents OpenAPI au format YAML, qui offre une alternative plus lisible que JSON.
- Descriptions de réponse améliorées : l'attribut ProducesResponseType inclut désormais un paramètre Description facultatif, qui vous permet de fournir plus de contexte pour les réponses de votre API.
Améliorations des API minimales :
- Validation intégrée : Vous pouvez désormais activer la validation automatique des paramètres de requête, d'en-tête et de corps de requête en appelant AddValidation(). Si la validation échoue, le framework renvoie automatiquement une réponse 400 Bad Request avec les détails de la validation. Cela fonctionne avec DataAnnotations et prend en charge les objets et collections imbriqués.
- Événements envoyés par le serveur (SSE) : une nouvelle méthode TypedResults.ServerSentEvents() facilite la diffusion en continu des mises à jour en temps réel aux clients via une seule connexion HTTP.
- Réponses d'erreur personnalisables : vous pouvez désormais intégrer votre logique de validation à IProblemDetailsService pour créer des réponses d'erreur cohérentes et personnalisées.
Observabilité et diagnostics améliorés
.NET 10 apporte des améliorations significatives en matière d'observabilité et de diagnostics, facilitant ainsi la surveillance et le dépannage de vos applications ASP.NET Core.
- Nouvelles métriques intégrées : ASP.NET Core inclut désormais un ensemble complet de nouvelles métriques pour surveiller les composants clés, notamment Blazor, l'authentification et l'autorisation, l'identité et le nouveau pool de mémoire.
- Amélioration du traçage Blazor : le traçage Blazor Server a été amélioré afin de fournir des informations plus détaillées sur l'activité du circuit, ce qui facilite le diagnostic des problèmes en temps réel.
- Outils de diagnostic Blazor WebAssembly : de nouveaux outils de diagnostic sont disponibles pour les applications Blazor WebAssembly, vous permettant de collecter des profils de performances CPU, de capturer des vidages de mémoire et de recueillir des métriques d'exécution.
.NET MAUI – Créer des applications natives multiplateformes
.NET MAUI est le meilleur moyen de créer des applications natives multiplateformes pour iOS, Android, macOS et Windows avec .NET et C#.
Mises à jour de la plateforme :
- Liaisons Android 16 (API 36 et 36.1) avec les dernières fonctionnalités de la plateforme
- Liaisons iOS 26.0 pour les dernières fonctionnalités iOS
- Méthodes Marshal activées : performances de démarrage améliorées par défaut
Améliorations des contrôles :
- HybridWebView : nouveaux événements d'initialisation (WebViewInitializing, WebViewInitialized) pour la personnalisation spécifique à la plateforme, surcharge InvokeJavaScriptAsync et gestion des exceptions JavaScript
- Interception des requêtes Web : modification des en-têtes, redirection des requêtes ou fourniture de réponses locales pour BlazorWebView et HybridWebView- CollectionView/CarouselView : gestionnaires iOS améliorés désormais par défaut
- MediaPicker : gestion EXIF automatique, sélection de plusieurs fichiers avec PickMultipleAsync, prise en charge de la compression d'images
- Gestion SafeArea : améliorée pour prendre en charge plusieurs plateformes à partir de la nouvelle API SafeAreaEdges
- Éléments de la barre d'outils secondaire : ajoutés pour iOS et macOS
Améliorations XAML :
.NET MAUI dans .NET 10 introduit des améliorations XAML significatives qui rationalisent le développement et améliorent les performances :
- Espaces de noms XML globaux et implicites (optionnels) : simplifiez le balisage XAML en éliminant les déclarations d'espaces de noms répétitives.
- Nouveau générateur de source XAML : temps de compilation plus rapides et meilleure prise en charge d'IntelliSense grâce au traitement XAML au moment de la compilation.
Avec les espaces de noms globaux, vous pouvez déclarer les références xmlns une seule fois dans un fichier GlobalXmlns.cs et utiliser des types sans préfixes dans tous vos fichiers XAML :
Avant :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 | <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:models="clr-namespace:MyApp.Models" xmlns:controls="clr-namespace:MyApp.Controls" x:Class="MyApp.MainPage"> <controls:TagView x:DataType="models:Tag" /> </ContentPage> |
Après :
| Code C# : | Sélectionner tout |
1 2 3 | <ContentPage x:Class="MyApp.MainPage"> <TagView x:DataType="Tag" /> </ContentPage> |
Il n'est pas nécessaire de déclarer xmlns:models ou xmlns:controls, car ils sont déclarés globalement dans un fichier GlobalXmlns.cs. Aucun préfixe n'est requis pour TagView ou Tag.
Exemple de sélection de plusieurs fichiers dans MediaPicker :
| Code C# : | Sélectionner tout |
1 2 3 4 5 | var result = await MediaPicker.PickMultipleAsync(new MediaPickerOptions { MaximumWidth = 1024, MaximumHeight = 768 }); |
Autres points forts :
- Intégration Aspire : nouveau modèle de projet avec télémétrie et découverte de services
- Diagnostics : surveillance complète des performances de mise en page avec ActivitySource et des métriques
- Priorité à la qualité : améliorations continues en matière de fiabilité et de performances.
Entity Framework Core 10 – Accès avancé aux données
Entity Framework Core 10 apporte des améliorations puissantes en matière d'accès aux données, notamment la recherche vectorielle compatible avec l'IA, une prise en charge JSON améliorée et une meilleure gestion des types complexes.
Azure SQL et SQL Server :
- Prise en charge de la recherche vectorielle : prise en charge complète du nouveau type de données vector et de la fonction VECTOR_DISTANCE(), permettant des charges de travail IA telles que la recherche sémantique et RAG avec SQL Server 2025 et Azure SQL Database
- Type de données JSON : utilisation automatique du type json natif de SQL Server 2025 pour de meilleures performances et une requête sécurisée avec prise en charge complète de LINQ à l'aide des clauses JSON_VALUE() et RETURNING- Noms de contraintes par défaut personnalisés : spécifiez des noms pour les contraintes par défaut ou...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.
