Microsoft présente les nouvelles fonctionnalités du langage de programmation de C# 14

**Jade Emy** · 14/05/2025, 20h44

Microsoft présente les nouvelles fonctionnalités du langage de programmation de C# 14 : membres d’extension, affectation par condition nulle, propriétés field stockées

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. Vous pouvez essayer ces fonctionnalités à l’aide de la dernière version de Visual Studio 2022 ou du Kit de développement logiciel (SDK) .NET 10.

Le langage en C# constitue le langage le plus connu pour la plateforme .NET, un environnement de développement gratuit, open source et multiplateforme. Les programmes en C# peuvent s’exécuter sur plusieurs appareils différents, des appareils Internet des objets (IoT) au cloud et partout entre les deux. Vous pouvez écrire des applications pour les téléphones, les appareils de bureau, les ordinateurs portables et les serveurs.

De nouvelles fonctionnalités sont disponible pour C#14 et vous pouvez essayer ces fonctionnalités à l’aide de la dernière version de Visual Studio 2022 ou du Kit de développement logiciel (SDK) .NET 10. Voici les nouvelles fonctionnalités suivantes de C#14 :

Membres d’extension
Affectation par condition nulle
nameof prend en charge les types génériques non liés
Conversions implicites supplémentaires pour Span<T> et ReadOnlySpan<T>
Modificateurs sur des paramètres lambda simples
Propriétés field stockées
Événements et constructeurs partial

Membres d’extension

C# 14 ajoute une nouvelle syntaxe pour définir des membres d’extension. La nouvelle syntaxe vous permet de déclarer des propriétés d’extension en plus des méthodes d’extension. Vous pouvez également déclarer des membres d’extension qui étendent le type, plutôt qu’une instance du type. En d’autres termes, ces nouveaux membres d’extension peuvent apparaître en tant que membres statiques du type que vous étendez. L’exemple de code suivant montre un exemple des différents types de membres d’extension que vous pouvez déclarer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 Enumerable
{
    // Extension block
    extension<TSource>(IEnumerable<TSource> source) // extension members for IEnumerable<TSource>
    {
        // Extension property:
        public bool IsEmpty => !source.Any();
        // Extension indexer:
        public TSource this[int index] => source.Skip(index).First();
 
        // Extension method:
        public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { ... }
    }
 
    // extension block, with a receiver type only
    extension<TSource>(IEnumerable<TSource>) // static extension members for IEnumerable<Source>
    {
        // static extension method:
        public static IEnumerable<TSource> Combine(IEnumerable<TSource> first, IEnumerable<TSource> second) { ... }
 
        // static extension property:
        public static IEnumerable<TSource> Identity => Enumerable.Empty<TSource>();
    }
}

Les membres du premier bloc d’extension sont appelés comme s’ils sont des membres d’instance de IEnumerable<TSource>, par exemple sequence.IsEmpty. Les membres du deuxième bloc d’extension sont appelés comme s’ils sont des membres statiques de IEnumerable<TSource>, par exemple IEnumerable<int>.Identity.

Mot clé field

Le jeton field vous permet d’écrire un corps d’accesseur de propriété sans déclarer de champ de stockage explicite. Le jeton field est remplacé par un champ de stockage synthétisé par un compilateur.

Par exemple, auparavant, si vous souhaitiez vous assurer qu’une propriété string ne pouvait pas être définie sur null, vous deviez déclarer un champ de stockage et implémenter les deux accesseurs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
private string _msg;
public string Message
{
    get => _msg;
    set => _msg = value ?? throw new ArgumentNullException(nameof(value));
}

Vous pouvez maintenant simplifier votre code pour :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

Vous pouvez déclarer un corps pour un accesseur ou les deux accesseurs d’une propriété stockée dans un champ.

Il existe un risque de changement cassant ou de confusion lors de la lecture de code dans les types qui incluent également un symbole nommé field. Vous pouvez utiliser @field ou this.field lever l’ambiguïté entre le field mot clé et l’identificateur, ou renommer le symbole actuel field pour fournir une meilleure distinction.

Le mot clé contextuel field est en C# 13 comme fonctionnalité d’aperçu.

Conversions de portée implicites

C# 14 introduit la prise en charge de première classe pour System.Span<T> et System.ReadOnlySpan<T> dans le langage. Cette prise en charge implique de nouvelles conversions implicites permettant une programmation plus naturelle avec ces types.

Span<T> et ReadOnlySpan<T> sont utilisés de nombreuses façons clés en C# et au runtime. Leur introduction améliore les performances sans risquer la sécurité. C# 14 reconnaît la relation et prend en charge certaines conversions entre ReadOnlySpan<T>, Span<T> et
T[]. Les types d’étendues peuvent être des récepteurs de méthode d’extension, se combiner avec d’autres conversions et faciliter des scénarios d’inférence de types génériques.

Types génériques non liés et nameof

À partir de C# 14, l’argument à nameof peut être un type générique non lié. Par exemple, nameof(List<>) a pour résultat List. Dans les versions antérieures de C#, seuls les types génériques fermés, tels que List<int>, peuvent être utilisés pour retourner le List nom.

Paramètres lambda simples avec modificateurs

Vous pouvez ajouter des modificateurs de paramètre, tels que scoped, refin, out ou ref readonly à des paramètres d’expression lambda sans spécifier le type de paramètre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
delegate bool TryParse<T>(string text, out T result);
// ...
TryParse<int> parse1 = (text, out result) => Int32.TryParse(text, out result);

Auparavant, l’ajout de modificateurs n’était autorisé que lorsque les déclarations de paramètres incluaient les types des paramètres. La déclaration précédente nécessite des types sur tous les paramètres :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

TryParse<int> parse2 = (string text, out int result) => Int32.TryParse(text, out result);

Le params modificateur nécessite toujours une liste de paramètres typée explicitement.

Plus de membres partiels

Vous pouvez maintenant déclarer les constructeurs d’instances et les événements en tant que membres partiels.

Les constructeurs partiels et les événements partiels doivent inclure exactement une déclaration de définition et une déclaration d’implémentation.

Seule la déclaration d’implémentation d’un constructeur partiel peut inclure un initialiseur de constructeur : this() ou base(). Une seule déclaration de type partiel peut inclure la syntaxe du constructeur principal.

La déclaration d’implémentation d’un événement partiel doit inclure les accesseurs add et remove. La déclaration de définition déclare un événement de type champ.

Affectation conditionnelle nulle

Les opérateurs d’accès de membre conditionnel null, ?. et ?[], peuvent désormais être utilisés sur le côté gauche d'une affectation ou d'une affectation composée.

Avant C# 14, vous devez vérifier null une variable avant de l’affecter à une propriété :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (customer is not null)
{
    customer.Order = GetCurrentOrder();
}

Vous pouvez simplifier le code précédent à l’aide de l’opérateur ?. :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

customer?.Order = GetCurrentOrder();

Le côté droit de l’opérateur = est évalué uniquement lorsque le côté gauche n’est pas null. Si customer est nul, le code n’appelle pas GetCurrentOrder.

En plus de l’affectation, vous pouvez utiliser des opérateurs d’accès membre conditionnel null avec des opérateurs d’affectation composée (+= et -= d’autres). Cependant, l'incrémentation et la décrémentation, ++ et --, ne sont pas autorisées.

Source : Microsoft

Et vous ?

Pensez-vous que ces nouvelles fonctionnalités sont crédibles ou pertinentes ?

Quel est votre avis sur le sujet ?

Voir aussi :

Microsoft publie .NET 10 Preview 1 : cette préversion donne un aperçu de C# 14 et met l'accent sur des améliorations de performance, des optimisations des bibliothèques et une expérience développeur enrichie

C# 13 : Découvrez les dernières fonctionnalités en avant-première, dont l'amélioration de la collection params et la résolution des surcharges, ainsi que l'ajout des propriétés partielles

**Jade Emy** · 18/11/2025, 12h01

Microsoft présente les nouvelles fonctionnalités de C# 14 qui devraient permettre aux développeurs C# de bénéficier de certaines des améliorations de performances offertes par .NET 10.

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 traitement UTF-8 et les routines numériques qui en bénéficient. Deux ajouts au langage en particulier permettent des implémentations de bibliothèques plus propres et plus rapides : les conversions implicites de span et l'affectation composée définie par l'utilisateur.

Conversions implicites de span

Span<T> / ReadOnlySpan<T> sont au cœur des API sans allocation. C# 14 ajoute des conversions implicites entre les tableaux, les spans et les spans en lecture seule, ce qui vous permet d'écrire moins de code et au JIT de voir des graphiques d'appel plus simples. Cela se traduit par moins de variables temporaires, moins de vérifications de limites et une intégration plus agressive dans le framework (comme décrit dans les sections du blog sur les performances consacrées aux micro-benchmarks de texte et d'analyse).

Les versions antérieures de C# nécessitaient un code comme celui-ci :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
// Before
string line = ReadLine();
ReadOnlySpan<char> key = line.AsSpan(0, 5); // explicit AsSpan
ProcessKey(key);
 
int[] buffer = GetBuffer();
Span<int> head = new(buffer, 0, 8); // explicit Span ctor
Accumulate(head);

Désormais, vous pouvez écrire ce qui suit :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// After (C# 14)
string line = ReadLine();
ProcessKey(line[..5]);              // substring slice implicitly converts
 
int[] buffer = GetBuffer();
Accumulate(buffer[..8]);

Les auteurs de bibliothèques exploitent ces conversions pour supprimer les variables locales d'aide et exprimer l'intention de découpage en ligne. Les avantages comprennent moins d'appels explicites à AsSpan ou au constructeur, une intention de découpage plus claire qui encourage les surcharges adaptées aux spans, et des optimisations du framework qui réduisent les allocations grâce à des chemins d'allocation zéro plus larges.

Affectation composée définie par l'utilisateur

Les types numériques et vectoriels haute performance accumulent souvent des valeurs dans des boucles serrées. Sans opérateur d'affectation composé dédié, le code répétait la référence de gauche ou créait des temporaires intermédiaires via un opérateur binaire ordinaire, deux modèles pouvant empêcher certaines optimisations JIT. C# 14 vous permet de déclarer explicitement un opérateur d'affectation composé (+=, -=, etc.) afin que le compilateur le distribue directement à votre implémentation. Les bibliothèques tirant parti de cette fonctionnalité (par exemple, les aides compatibles SIMD référencées dans le blog sur les performances) évitent les variables temporaires supplémentaires et peuvent exposer des API plus idiomatiques.

Au lieu de cela :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// Before
BigVector sum = BigVector.Zero;
foreach (var v in values)
{
 sum = sum.Add(v); // intermediate result each iteration
}

Après avoir fourni un opérateur composé capable de mettre à jour le résultat sur place :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// After (C# 14)
BigVector sum = BigVector.Zero;
foreach (var v in values)
{
 sum += v; // calls user-defined operator += directly
}

Définition des opérateurs binaires et composés :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public struct BigVector(float x, float y, float z)
{
 public float X { get; private set => value = field; } = x;
 public float Y { get; private set => value = field; } = y;
 public float Z { get; private set => value = field; } = z;
 
 public static BigVector operator +(BigVector l, BigVector r)
  => new(l.X + r.X, l.Y + r.Y, l.Z + r.Z);
 
 public void operator +=(BigVector r)
 {
  X += r.X;
  Y += r.Y;
  Z += r.Z;
 }
}