Voici un aperçu rapide de ce que Microsoft a apporté dans C# 14 : de nouvelles extensions, un certain nombre de fonctionnalités qui vous rendent plus productif et des améliorations qui optimisent les performances de vos programmes C#. Les nouvelles fonctionnalités de C# 14 devraient permettre aux développeurs C# de bénéficier de certaines des améliorations de performances offertes par .NET 10.C# est un langage de programmation orientée objet, commercialisé par Microsoft depuis 2002 et destiné à développer sur la plateforme Microsoft .NET, au même titre que d’autres langages liés à cette plateforme (ex. : VB .NET, J#, etc.). C# est dérivé du C++ et très proche du Java dont il reprend la syntaxe générale ainsi que les concepts, y ajoutant des notions telles que la surcharge des opérateurs, les indexeurs et les délégués. Il est utilisé notamment pour développer des applications web sur la plateforme ASP.NET, ainsi que des jeux vidéo avec les moteurs de jeux Unity et Godot.
En mai, Microsoft a présenté les nouvelles fonctionnalités du langage de programmation de C# 14. C# 14 inclut les nouvelles fonctionnalités suivantes : Membres d’extension, Mot clé field, Conversions de portée implicites, Types génériques non liés et nameof, Paramètres lambda simples avec modificateurs, Plus de membres partiels, Affectation conditionnelle nulle. Ces fonctionnalités sont disponible à l’aide de la dernière version de Visual Studio 2022.
Récemment, Microsoft a annoncé la dernière version de son framework logiciel .NET 10, apportant des améliorations au compilateur JIT, des améliorations NativeAOT, ainsi que l'optimisation du runtime. 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.
C# 14 est fourni avec .NET 10. Les nouveaux membres extension constituent la principale nouveauté, mais de nombreuses autres fonctionnalités vous permettront d'améliorer votre productivité en tant que développeur. Microsoft a également ajouté de nouvelles fonctionnalités à C# 14 qui devraient permettre de bénéficier de certaines des améliorations de performances offertes par .NET 10.
Membres Extension
Les membres extension sont la fonctionnalité phare de C# 14. La nouvelle syntaxe est entièrement compatible avec les méthodes extension existantes. Les membres extension permettent d'utiliser des propriétés extension, des opérateurs extension et des membres extension statiques.
Le code suivant montre un exemple de bloc d'extension. Le bloc d'extension contient deux extensions d'instance suivies de deux extensions statiques pour le même type. Le nom du récepteur, source, est facultatif si l'extension ne contient que des extensions statiques.
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | public static class EnumerableExtensions { // Instance-style extension members: 'source' is the receiver variable extension<TSource>(IEnumerable<TSource> source) { // Extension property public bool IsEmpty => !source.Any(); // Extension method (body elided for brevity) public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { // Implementation would filter 'source' throw new NotImplementedException(); } // Static extension property public static IEnumerable<TSource> Identity => Enumerable.Empty<TSource>(); // Static user-defined operator provided as an extension public static IEnumerable<TSource> operator +( IEnumerable<TSource> left, IEnumerable<TSource> right) => left.Concat(right); } } |
Exemples d'utilisation :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 | int[] data = ...; // access instance extension property: if (data.IsEmpty) { /* ... */ } // Access static extension operator + var combined = data + [ 4, 5 ]; // Access static extension property: var empty = IEnumerable<int>.Identity; |
Les blocs d'extension étant compatibles au niveau de la source et du binaire avec les méthodes extension existantes, vous pouvez migrer une méthode à la fois. Les assemblages dépendants n'ont pas besoin d'être recompilés et continuent à se lier au symbole d'origine.
Plus de productivité pour vous
Cet ensemble de fonctionnalités linguistiques partage un objectif commun : réduire les frictions syntaxiques pour les tâches quotidiennes afin que vous puissiez vous concentrer sur la logique du domaine plutôt que sur la cérémonie. Elles éliminent les passages standard, suppriment les blocs conditionnels courants, simplifient les déclarations lambda, améliorent les types partiels pour les générateurs de source et rendent [c]nameof[/cc] plus expressif dans les scénarios génériques. Individuellement, chacune d'entre elles permet d'économiser quelques lignes et de réduire la saisie. Ensemble, elles se traduisent par un code plus propre, moins d'identificateurs triviaux et un code qui communique plus clairement l'intention.
- Le mot-clé field
- Types génériques non liés et nameof
- Paramètres lambda simples avec modificateurs
- Affectation conditionnelle null
- Événements et constructeurs partiels
Le mot-clé field
La plupart des propriétés commencent leur vie comme de simples propriétés auto-implémentées. Plus tard, vous découvrez que vous avez besoin de petits éléments de logique (fusion de valeurs null, clamping, normalisation simple ou activation d'une garde) sur un seul accesseur. Avant C# 14, cette exigence vous obligeait à convertir en un modèle de champ de support entièrement écrit à la main :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 | // Before private string _message = ""; public string Message { get => _message; init => _message = value ?? throw new ArgumentNullException(nameof(value)); } |
Le mot-clé contextuel field crée une étape intermédiaire dans cette évolution : conserver la concision de la propriété automatique, injecter un minimum de logique uniquement là où cela est nécessaire et laisser le compilateur synthétiser et nommer le stockage de support. Vous ajoutez simplement le corps de l'accesseur qui nécessite de la logique et vous faites référence au stockage généré par le compilateur via field :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 | // After (C# 14) public string Message { get; // auto get init => field = value ?? throw new ArgumentNullException(nameof(value)); } |
Il s'agit d'un pont entre les propriétés implémentées automatiquement et celles entièrement écrites à la main : commencez par public string Message { get; init; }, puis, lorsque vous avez besoin d'une protection rapide, convertissez uniquement l'accesseur qui nécessite du code et utilisez field au lieu d'introduire un membre privé et de dupliquer un getter trivial. Ce modèle s'adapte lorsque de nombreuses propriétés nécessitent chacune une vérification d'une ligne : votre classe reste visuellement légère et les différences restent minimes. Un autre avantage de field est qu'il évite de créer un nouveau champ privé nommé. Tout le code du type doit utiliser la propriété pour accéder à la valeur de la propriété ou la modifier.
Types génériques non liés et nameof
Auparavant, pour enregistrer ou lancer en utilisant uniquement le nom du type générique, vous deviez soit coder en dur une chaîne, soit utiliser un type construit fermé :
| Code C# : | Sélectionner tout |
1 2 3 4 | // Before var listTypeName = nameof(List<int>); // "List" // or: const string Expected = "List"; |
Désormais, nameof accepte un type générique non lié. Cette fonctionnalité supprime la nécessité de choisir un argument de type arbitraire uniquement pour récupérer le nom du type générique :
| Code C# : | Sélectionner tout |
1 2 | // After (C# 14) var listTypeName = nameof(List<>); // "List" |
Cela produit le nom du type générique une seule fois, sans impliquer d'instanciation spécifique.
Paramètres lambda simples avec modificateurs
Dans les versions précédentes, les modificateurs de paramètres tels que out dans les délégués nécessitaient des annotations de type complètes sur tous les paramètres :
| Code C# : | Sélectionner tout |
1 2 3 | // Before delegate bool TryParse<T>(string text, out T value); TryParse<int> parse = (string text, out int result) => int.TryParse(text, out result); |
Désormais, vous pouvez conserver la forme concise implicitement typée tout en utilisant des modificateurs tels que out, ref, in, scoped sur un ou plusieurs paramètres :
| Code C# : | Sélectionner tout |
1 2 | // After (C# 14) TryParse<int> parse = (text, out result) => int.TryParse(text, out result); |
Les types de paramètres sont toujours déduits, ce qui préserve la syntaxe concise de l'expression lambda.
Affectation conditionnelle null
Les affectations protégées nécessitaient auparavant une vérification null explicite :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 | // Before if (customer is not null) { customer.Order = CreateOrder(); customer.Total += CalculateIncrement(); } |
Vous pouvez désormais affecter (et utiliser une affectation composée) directement avec des opérateurs conditionnels null sur le côté gauche de l'affectation. Le côté droit n'est évalué que lorsque le récepteur de l'affectation n'est pas null :
| Code C# : | Sélectionner tout |
1 2 3 | // After (C# 14) customer?.Order = CreateOrder(); customer?.Total += CalculateIncrement(); |
Cela réduit l'indentation et centre visuellement le travail important. La fonctionnalité s'intègre directement aux opérateurs conditionnels null existants afin qu'ils puissent apparaître à gauche d'une affectation. Elle évalue l'expression de droite uniquement lorsque le récepteur n'est pas null, évitant ainsi les variables locales d'aide ou les vérifications dupliquées.
Événements partiels et constructeurs
Les types partiels générés ou générés à partir de sources volumineux peuvent désormais répartir la logique des événements et des constructeurs entre plusieurs fichiers, ce qui permet aux générateurs ou aux différents fichiers de contribuer de manière claire :
| Code C# : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | public partial class Widget(int size, string name) // defining declaration of primary ctor { public partial event EventHandler Changed; // declaring event declaration (field-like) } public partial class Widget { public partial event EventHandler Changed // Defining declaration for event. { add => _changed += value; remove => _changed -= value; } private EventHandler? _changed; // Implementing declaration can add constructor body logic public Widget { Initialize(); } } |
Cette séparation permet de nouveaux scénarios de génération de sources (par exemple, un générateur fournit les membres de définition, le code utilisateur fournit le comportement, ou vice-versa). Elle simplifie la logique créée manuellement. Elle reste davantage axée sur les algorithmes que vous écrivez à la main.
Plus de performances pour vos utilisateurs
La plupart des gains de débit bruts que vous constaterez après la mise à niveau vers .NET 10 proviennent de l'adoption par le runtime et la BCL des nouvelles fonctionnalités de C# 14. Les bibliothèques de base utilisent déjà ces fonctionnalités, de sorte que vos applications sont souvent plus rapides, même si vous n'écrivez jamais cette syntaxe vous-même. L'article sur les améliorations des performances de .NET 10 met en avant l'analyse syntaxique intensive, le...
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.
