C# 14 et .NET 10 : nouvelles fonctionnalités du langage en 2026

C# évolue à un rythme tenu : la version 13 a accompagné .NET 9 en novembre 2024, et la 14 ferme la marche avec .NET 10 LTS sorti le 11 novembre 2025. Ensemble, ces deux paliers introduisent une vague de fonctionnalités qui changent concrètement la productivité au quotidien : membres d’extension (extension properties, opérateurs, membres statiques étendus), propriétés à champ généré accessibles via le mot-clé field, conversions implicites de Span, paramètres params sur ReadOnlySpan, types de retour partial, exécution d’un fichier .cs autonome via dotnet run. Ce tutoriel reprend les apports les plus structurants pour un projet de production en 2026, avec des exemples utilisables tels quels.

Prérequis

• .NET 10 LTS installé (cf. Installer .NET 9, à mettre à jour avec dotnet --version)
• Notions C# (classes, génériques, async)
• IDE : Visual Studio 2026, JetBrains Rider 2025.3+, ou VS Code + C# Dev Kit
• Temps estimé : 75 minutes

Étape 1 — Membres d’extension : au-delà des méthodes

Depuis C# 3.0, on étendait un type avec des méthodes d’extension. C# 14 généralise ce mécanisme à tous les membres : propriétés, opérateurs, indexeurs, membres statiques. La syntaxe utilise un bloc extension(T target) qui désigne la cible. C’est la fonctionnalité la plus visible de C# 14 et celle qui change le plus vite vos habitudes.

public static class StringExtensions
{
    extension(string s)
    {
        // Propriété d'extension
        public bool IsNumeric => s.All(char.IsDigit);

        // Indexeur d'extension
        public char this[Index i] => s[i];
    }

    extension(string)
    {
        // Membre statique d'extension
        public static string Empty => string.Empty;
    }
}

// Usage
string id = "12345";
if (id.IsNumeric) Console.WriteLine("numérique");

Trois points pratiques. Une propriété d’extension est read-only (pas de setter) puisqu’elle ne peut stocker d’état dans le type étendu. Les opérateurs d’extension permettent enfin de définir +, -, etc. sans modifier le type source — utile pour ajouter des opérations à un type tiers. Les membres statiques d’extension permettent d’enrichir l’API statique d’un type (string.Empty, DateTime.UnixEpoch) sans hériter.

Étape 2 — Propriétés à champ généré (field keyword)

C# 13 introduit le mot-clé contextuel field dans les accessors d’une propriété. Il référence le champ de stockage généré automatiquement par le compilateur, ce qui évite de déclarer manuellement un backing field privé pour ajouter une validation ou un effet de bord.

public class Utilisateur
{
    // Avant C# 13 — il fallait un _email privé séparé
    public string Email
    {
        get => field;
        set => field = value?.Trim().ToLowerInvariant()
            ?? throw new ArgumentNullException(nameof(value));
    }

    // Validation à l'écriture, lecture transparente
    public int Age
    {
        get;
        set => field = value >= 0 ? value : throw new ArgumentOutOfRangeException();
    }
}

Cette syntaxe élimine le bruit visuel des backing fields privés tout en préservant la possibilité d’ajouter logique de validation, journalisation, ou notification de changement. Pour 80 % des cas où vous écriviez un private string _email; public string Email { get => _email; set => _email = ...; }, vous écrivez désormais directement dans la propriété.

Étape 3 — params ReadOnlySpan et conversions implicites de Span

Les méthodes params recevaient historiquement un params T[], ce qui allouait un tableau à chaque appel. C# 13 permet params ReadOnlySpan<T>, qui s’alloue sur la pile pour les petits cas. C# 14 va plus loin avec les conversions implicites : monArray[..8] devient automatiquement un Span<T> sans appel explicite à AsSpan().

// Allocation zéro pour les appels courts
public static int Somme(params ReadOnlySpan<int> valeurs)
{
    int total = 0;
    foreach (var v in valeurs) total += v;
    return total;
}

// Appels naturels — aucune allocation visible
var s1 = Somme(1, 2, 3);                    // OK
var s2 = Somme(new[] { 4, 5, 6 });          // OK
int[] tableau = { 10, 20, 30, 40 };
var s3 = Somme(tableau[..3]);               // OK conversion implicite C# 14

Pour les chemins chauds (parsing, sérialisation, transformations de séquences), ce changement supprime des centaines de milliers d’allocations par seconde sur des services à fort débit. Le coût mémoire chute, les pauses GC raccourcissent, la latence p99 s’améliore. C’est l’un des apports les plus bénéfiques pour les bibliothèques bas niveau.

Étape 4 — Types de retour partial et expanded partial

Les méthodes partial permettent de séparer la signature d’une méthode de son implémentation, classique pour le code généré (source generators). C# 13 étend cette mécanique aux propriétés et indexeurs partial, ce qui ouvre des scénarios d’augmentation par code généré beaucoup plus expressifs.

// Fichier généré par un source generator
public partial class Configuration
{
    public partial string DatabaseUrl { get; }
}

// Fichier écrit à la main
public partial class Configuration
{
    public partial string DatabaseUrl =>
        Environment.GetEnvironmentVariable("DATABASE_URL")
        ?? throw new InvalidOperationException("DATABASE_URL manquant");
}

L’avantage : le source generator peut déclarer un contrat (signature de propriété) que le développeur remplit côté code utilisateur, ou inversement. Les bibliothèques comme MediatR, Mapperly, ou les ORM peuvent désormais générer des propriétés partial que le code utilisateur enrichit, sans héritage forcé ni interface intermédiaire.

Étape 5 — Exécution d’un fichier .cs unique (dotnet run file)

.NET 10 introduit la capacité de lancer un fichier .cs autonome sans .csproj ni .sln. Pratique pour scripts ponctuels, snippets de démonstration, ou onboarding rapide d’un nouveau développeur.

# Créer un fichier minimal
cat > hello.cs <<'EOF'
#!/usr/bin/env dotnet run

using System;
Console.WriteLine($"Hello depuis .NET {Environment.Version}");
EOF

# Exécution directe
dotnet run hello.cs
# Ou sur Unix après chmod +x :
./hello.cs

Pour les besoins plus consistants (multi-fichier, dépendances), le format projet classique reste nécessaire. Mais pour un outil interne CLI de 50 lignes, un script de migration ponctuel, ou un exercice pédagogique, cette fonctionnalité supprime la cérémonie du projet et rapproche C# de l’expérience Python ou Node.

Étape 6 — JIT 2026 : AVX-512, ARM SVE2 et gains gratuits

.NET 10 a complètement revu le JIT pour exploiter AVX-512 (Intel/AMD), AVX10.2, et ARM SVE/SVE2. Concrètement, sans toucher au code, le runtime vectorise davantage d’opérations et délivre 15-30 % de performance brute en plus sur les serveurs modernes. Mesures officielles Microsoft : .NET 10 est 49 % plus rapide en temps de réponse moyen que .NET 8, et la sérialisation JSON via System.Text.Json gagne 20-40 %.

// Aucun changement de code — la vectorisation est transparente
public int SommeRapide(int[] valeurs)
{
    int total = 0;
    foreach (var v in valeurs) total += v;
    return total;
}
// Sur AVX-512, le JIT déroule la boucle et somme 16 entiers par cycle

Pour vérifier que la vectorisation s’applique sur votre code, BenchmarkDotNet (couvert dans le tutoriel dédié) affiche les instructions assembleur générées avec [DisassemblyDiagnoser]. C’est ainsi qu’on confirme qu’une boucle critique tire bien parti des registres vectoriels.

Étape 7 — Pattern matching enrichi et alias génériques

C# 14 améliore le pattern matching avec des nouveaux patterns sur les Span et autorise des alias génériques avec using. Ces deux ajouts réduisent le bruit sur des bases de code typées.

// Alias générique
using StringDictionary = System.Collections.Generic.Dictionary<string, string>;

public class Cache
{
    private readonly StringDictionary _entries = new();
}

// Pattern matching sur Span
ReadOnlySpan<char> input = "ABC123";
var resultat = input switch
{
    [.., 'X'] => "Termine par X",
    ['A', .., '3'] => "Commence par A, finit par 3",
    _ => "Autre"
};

Les alias génériques évitent de répéter de longues signatures (IReadOnlyDictionary<string, ImmutableArray<Customer>>) dans plusieurs fichiers. Le pattern matching sur Span permet d’écrire des parsers ad hoc sans regex pour des cas simples — gain à la fois en lisibilité et en perf.

Erreurs fréquentes

Foire aux questions

C# 14 nécessite-t-il .NET 10 ?
Oui pour les nouveautés. Sur .NET 8/9, vous restez sur C# 12/13. La rétrocompatibilité du langage avec d’anciens runtimes existe mais avec limitations.

Quand migrer de .NET 8 vers .NET 10 ?
.NET 8 LTS est supporté jusqu’à novembre 2026. Une migration vers .NET 10 LTS (supporté jusqu’à novembre 2028) est recommandée d’ici l’été 2026 pour bénéficier des perfs et préparer la transition tranquillement.

Les membres d’extension cassent-ils l’existant ?
Non. Les méthodes d’extension classiques restent supportées intactes. Le bloc extension est une syntaxe additionnelle.

field fonctionne-t-il avec init ?
Oui : public string Nom { get; init => field = value.Trim(); }.

Performance d’AOT vs JIT en .NET 10 ?
L’AOT démarre en < 50 ms pour 5-15 Mo de binaire, mais perd 10-20 % en perf soutenue car pas de tiered compilation. Le JIT reste plus rapide pour les services long-running.

Pour aller plus loin

Avec ces fondations modernes en place, l’étape logique suivante est EF Core 10 pour la couche données ou gRPC ASP.NET Core pour les services à haute performance. Vue panoramique : C# et .NET moderne.

Ressources et références

• What’s new in C# 14 — Microsoft Learn
• .NET 10 overview
• C# Language Design — GitHub
• DevBlogs .NET