Nouveautés, de C# 8 à C# 15

// Program.cs d'un projet net10.0 sans LangVersion, compile par le SDK 10.0.300.
#error version

// error CS1029: #error: 'version'
// error CS8304: Compiler version: '5.6.0-2.26230.102 (caa81fa4971f74880cdab61990cb1b11420939ec)'.
//   Language version: 14.0. Compiler path: 'C:\Program Files\dotnet\sdk\10.0.300\Roslyn\bincore\Microsoft.CodeAnalysis.CSharp.dll'.

// Le meme fichier avec <LangVersion>preview</LangVersion> : Language version: preview.

// Le meme fichier dans un projet net11.0, compile par le SDK 11.0.100-rc.1.26425.128 :
// error CS1029: #error: 'version'
// error CS8304: Compiler version: '5.11.0-1.26425.128 (3551975be08744f0418857c5bed8ab1545c5dd47)'.
//   Language version: 15.0. Compiler path: 'C:\Program Files\dotnet\sdk\11.0.100-rc.1.26425.128\Roslyn\bincore\Microsoft.CodeAnalysis.CSharp.dll'.

// LangVersion 8.0 : pas encore d'instructions de niveau superieur, d'ou Main.
using System;
using System.IO;

static class Programme
{
    static void Main()
    {
        string[] etapes = { "creee", "payee", "expediee", "livree" };

        // Index depuis la fin, et plage : [1..3] prend les elements 1 et 2.
        // Sur un tableau, la plage est une copie ; sur un span, une vue.
        Console.WriteLine(etapes[^1]);
        Console.WriteLine(string.Join(", ", etapes[1..3]));

        // ??= n'affecte que si la variable est nulle.
        string? note = null;
        note ??= "sans note";
        Console.WriteLine(note);

        // Declaration using : liberee a la fin du bloc englobant, sans accolades.
        using var journal = new StringWriter();
        journal.Write("ecrit");
        Console.WriteLine(journal);
    }
}
// livree
// payee, expediee
// sans note
// ecrit

// Sous LangVersion 7.3 (et <Nullable>disable</Nullable>, sinon CS8630 d'abord),
// cinq erreurs CS8370, dont la premiere :
// error CS8370: Feature 'index operator' is not available in C# 7.3. Please use language version 8.0 or greater.

// LangVersion 9.0 : instructions de niveau superieur, plus de classe Program.
using System;
using System.Collections.Generic;

// new() prend le type de la cible.
List<Commande> commandes = new()
{
    new() { Reference = "C-1", Montant = 40m },
    new() { Reference = "C-2", Montant = 1200m },
};

foreach (var c in commandes)
{
    Console.WriteLine($"{c.Reference} : {Palier(c.Montant)}");
}
// C-1 : standard
// C-2 : a valider

// commandes[0].Montant = 0m;
// error CS8852: Init-only property or indexer 'Commande.Montant' can only be assigned in an object
//   initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor.

// Motifs relationnels et logiques.
static string Palier(decimal montant) => montant switch
{
    < 0m => "invalide",
    >= 0m and < 1000m => "standard",
    _ => "a valider",
};

class Commande
{
    public string Reference { get; init; } = "";
    public decimal Montant { get; init; }
}

// Sous LangVersion 8.0 :
// error CS8400: Feature 'init-only setters' is not available in C# 8.0. Please use language version 9.0 or greater.

// Trois fichiers d'un meme projet : Usings.cs, Frais.cs et Program.cs.

// Usings.cs : un global using vaut pour tous les fichiers du projet.
global using System;

// Frais.cs : espace de noms de portee fichier, sans accolades ni indentation.
namespace Boutique;

public readonly record struct Adresse(string Ville, string Pays);

public record Commande(string Reference, Adresse Livraison);

public static class Frais
{
    const string Devise = "EUR";

    // Chaine interpolee constante : tous les trous sont des constantes string.
    public const string Libelle = $"Frais de port en {Devise}";

    // Motif de propriete etendu : Livraison.Pays au lieu de Livraison: { Pays: ... }.
    public static decimal Calculer(Commande c) => c switch
    {
        { Livraison.Pays: "FR" } => 4.90m,
        { Livraison.Pays: "BE" or "LU" } => 9.90m,
        _ => 19.90m,
    };
}

// Program.cs : aucun using System ecrit, il vient du global using.
using Boutique;

var commande = new Commande("C-3", new Adresse("Namur", "BE"));
Console.WriteLine($"{Frais.Libelle} : {Frais.Calculer(commande)}");
// Frais de port en EUR : 9,90   (culture fr-FR)

// Sous LangVersion 9.0, quatre erreurs CS8773, dont :
// error CS8773: Feature 'file-scoped namespace' is not available in C# 9.0. Please use language version 10.0 or greater.

// LangVersion 10.0. Rien n'oblige l'appelant a renseigner Email.
using System;

var client = new Client { Nom = "Durand" };
Console.WriteLine($"[{client.Email}] {client.Email.Length}");
// [] 0 : l'oubli compile, et la valeur factice circule comme une vraie adresse.

class Client
{
    public string Nom { get; init; } = "";

    // "" ne sert qu'a faire taire l'avertissement du nullable (CS8618).
    public string Email { get; init; } = "";
}

// LangVersion 11.0 : required oblige chaque initialiseur a renseigner la propriete.
using System;

// var incomplet = new Client { Nom = "Durand" };
// error CS9035: Required member 'Client.Email' must be set in the object initializer or attribute constructor.

var client = new Client { Nom = "Durand", Email = "[email protected]" };
Console.WriteLine($"[{client.Email}] {client.Email.Length}");
// [[email protected]] 17

class Client
{
    // Plus de valeur factice : le nullable sait que l'initialiseur fournira la valeur.
    public required string Nom { get; init; }
    public required string Email { get; init; }
}

// Sous LangVersion 10.0 :
// error CS8936: Feature 'required members' is not available in C# 10.0. Please use language version 11.0 or greater.

// C# 12 : alias de n'importe quel type, ici un tuple.
using System;
using System.Collections.Generic;
using Ligne = (string Reference, int Quantite);

// C# 12 : une expression de collection prend le type de sa cible ; .. etale.
int[] premieres = [3, 1];
List<int> quantites = [.. premieres, 2];
Ligne[] lignes = [("USB-64", 3), ("SSD-1T", 1)];

// C# 13 : params accepte d'autres collections qu'un tableau, ici un span.
Console.WriteLine(Total(3, 1, 2));
Console.WriteLine(Total([.. quantites, 4]));
Console.WriteLine(lignes[^1].Reference);
// 6
// 10
// SSD-1T

static int Total(params ReadOnlySpan<int> valeurs)
{
    int total = 0;
    foreach (int v in valeurs)
    {
        total += v;
    }
    return total;
}

// Sous LangVersion 12.0 :
// error CS9202: Feature 'params collections' is not available in C# 12.0. Please use language version 13.0 or greater.
// Sous LangVersion 11.0, des l'alias :
// error CS9058: Feature 'using type alias' is not available in C# 11.0. Please use language version 12.0 or greater.

// LangVersion 12.0.
using System;

var compte = new Compte("FR76-001", 100m);
compte.Crediter(50m);
Console.WriteLine($"{compte.Solde} / {compte.Resume()}");
// 100 / FR76-001 : 150

// Le parametre solde sert deux fois : il initialise la propriete Solde, et les
// methodes le capturent. Deux copies du meme etat, qui divergent au premier credit.
// warning CS9124: Parameter 'decimal solde' is captured into the state of the enclosing type
//   and its value is also used to initialize a field, property, or event.
class Compte(string iban, decimal solde)
{
    public decimal Solde { get; } = solde;

    public void Crediter(decimal montant) => solde += montant;

    public string Resume() => $"{iban} : {solde}";
}

// LangVersion 12.0.
using System;

var compte = new Compte("FR76-001", 100m);
compte.Crediter(50m);
Console.WriteLine($"{compte.Solde} / {compte.Resume()}");
// 150 / FR76-001 : 150

// Les parametres ne servent qu'a initialiser : l'etat vit dans un seul membre, declare.
class Compte(string iban, decimal soldeInitial)
{
    public string Iban { get; } = iban;

    public decimal Solde { get; private set; } = soldeInitial;

    public void Crediter(decimal montant) => Solde += montant;

    public string Resume() => $"{Iban} : {Solde}";
}

// Sous LangVersion 11.0 :
// error CS9058: Feature 'primary constructors' is not available in C# 11.0. Please use language version 12.0 or greater.

// LangVersion 14.0.
using System;
using System.Collections.Generic;
using System.Linq;

var panier = new Panier { Client = "  Durand " };
panier.Lignes.Add(12m);
panier.Lignes.Add(90m);

Console.WriteLine($"[{panier.Client}]");
Console.WriteLine($"{panier.Lignes.Total} {panier.Lignes.EstVide} {List<decimal>.Vide.Count}");
Console.WriteLine(nameof(List<>));
// [Durand]
// 102 False 0
// List

class Panier
{
    public List<decimal> Lignes { get; } = [];

    // field designe le champ que le compilateur genere : plus de _client a declarer.
    public string Client
    {
        get;
        set => field = value?.Trim() ?? throw new ArgumentNullException(nameof(value));
    } = "";
}

static class Extensions
{
    // Bloc d'extension : le recepteur est nomme une fois pour tous ses membres.
    extension(List<decimal> lignes)
    {
        public decimal Total => lignes.Sum();
        public bool EstVide => lignes.Count == 0;
    }

    // Sans nom de recepteur : des membres statiques, appeles sur le type.
    extension(List<decimal>)
    {
        public static List<decimal> Vide => [];
    }
}

// Sous LangVersion 13.0, ce fichier echoue des l'analyse du bloc extension,
// avec six erreurs de syntaxe (CS1513, CS1002, CS8803, CS1022), dont :
// error CS1513: } expected
// error CS8803: Top-level statements must precede namespace and type declarations.
// La propriete Client seule, dans un fichier sans bloc extension, donnerait :
// error CS9260: Feature 'field keyword' is not available in C# 13.0. Please use language version 14.0 or greater.

// Code ecrit pour C# 13 : un champ prive s'appelle field.
using System;

var capteur = new Capteur();
capteur.Seuil = 5;
Console.WriteLine($"{capteur.Seuil} {capteur.LireChamp()}");
// LangVersion 13.0 : 5 5
// LangVersion 14.0 : 5 99. Les accesseurs ecrivent dans un champ genere, plus dans le membre.
// warning CS9258: In language version 14.0, the 'field' keyword binds to a synthesized backing field
//   for the property. To avoid generating a synthesized backing field, and to refer to the existing
//   member, use 'this.field' or '@field' instead.

class Capteur
{
    private int field = 99;

    public int Seuil
    {
        get => field;
        set => field = value;
    }

    public int LireChamp() => this.field;
}

// Le membre est renomme : plus rien ne s'appelle field, le sens ne depend plus de la version.
using System;

var capteur = new Capteur();
capteur.Seuil = 5;
Console.WriteLine($"{capteur.Seuil} {capteur.LireChamp()}");
// LangVersion 13.0 et 14.0 : 5 5, sans avertissement.

class Capteur
{
    private int seuil = 99;

    public int Seuil
    {
        get => seuil;
        set => seuil = value;
    }

    public int LireChamp() => seuil;
}

// LangVersion 14.0.
using System;

var durand = new Client("C-1");
Client? Trouver(string id) => id == durand.Id ? durand : null;

int appels = 0;
DateTime Horodater()
{
    appels++;
    return new DateTime(2026, 9, 26);
}

// ?.= : la partie droite n'est evaluee que si la partie gauche n'est pas nulle.
Trouver("C-1")?.DerniereVisite = Horodater();
Trouver("C-9")?.DerniereVisite = Horodater();
Trouver("C-1")?.Visites += 1;
Console.WriteLine($"{appels} {durand.Visites} {durand.DerniereVisite:yyyy-MM-dd}");
// 1 1 2026-09-26

// Trouver("C-1")?.Visites++;
// error CS1059: The operand of an increment or decrement operator must be a variable, property or indexer

// Modificateur sur un parametre de lambda, sans ecrire son type.
Analyse<int> analyser = (texte, out valeur) => int.TryParse(texte, out valeur);
Console.WriteLine(analyser("42", out int n) ? n : -1);
// 42

delegate bool Analyse<T>(string texte, out T valeur);

class Client(string id)
{
    public string Id { get; } = id;
    public DateTime? DerniereVisite { get; set; }
    public int Visites { get; set; }
}

// Sous LangVersion 13.0 :
// error CS9260: Feature 'null conditional assignment' is not available in C# 13.0. Please use language version 14.0 or greater.
// error CS9260: Feature 'simple lambda parameter modifiers' is not available in C# 13.0. Please use language version 14.0 or greater.

// SDK 11.0.100-rc.1.26425.128, net11.0 sans LangVersion, donc C# 15.
// Meme sortie avec le SDK 10.0.300, net10.0 et <LangVersion>preview</LangVersion>.
using System;
using System.Collections.Generic;

string[] references = ["usb-64", "USB-64", "ssd-1t"];

// with(...) en tete : les arguments du constructeur de la collection.
HashSet<string> uniques = [with(StringComparer.OrdinalIgnoreCase), .. references];
List<string> copie = [with(capacity: 10), .. references];

Console.WriteLine($"{uniques.Count} {copie.Count} {copie.Capacity}");
// 2 3 10

// Sous LangVersion 14.0, avec le SDK 11, une fois par element with(...) :
// error CS9327: Feature 'collection expression arguments' is not available in C# 14.0. Please use language version 15.0 or greater.
// Avec le SDK 10.0.300, sous LangVersion 14.0 :
// error CS8652: The feature 'collection expression arguments' is currently in Preview and *unsupported*.
//   To use Preview features, use the 'preview' language version.

// SDK 11.0.100-rc.1.26425.128, net11.0, C# 15.
using System;

Paiement paiement = new Virement("FR76-001"); // conversion implicite depuis un cas
Console.WriteLine(Decrire(paiement));
// virement FR76-001

// Exhaustive sans bras _ : le compilateur connait la liste des cas.
static string Decrire(Paiement p) => p switch
{
    Carte c => $"carte {c.Numero}",
    Virement v => $"virement {v.Iban}",
};

public record Carte(string Numero);
public record Virement(string Iban);
public union Paiement(Carte, Virement);

// Sans le bras Virement, la compilation passe avec un avertissement :
// warning CS8509: The switch expression does not handle all possible values of its input type
//   (it is not exhaustive). For example, the pattern 'Virement' is not covered.

// Sous net10.0, meme en preview, avec le SDK 10.0.300 comme avec le SDK 11 :
// error CS0518: Predefined type 'System.Runtime.CompilerServices.IUnion' is not defined or imported
// error CS0656: Missing compiler required member 'System.Runtime.CompilerServices.UnionAttribute..ctor'

// SDK 11.0.100-rc.1.26425.128, net11.0, C# 15.
using System;

Console.WriteLine(Decrire(new Ouverte(40)));
// ouverte a 40 %

// Exhaustive sans bras _ : Fermee et Ouverte sont les seuls descendants directs.
static string Decrire(Vanne v) => v switch
{
    Fermee => "fermee",
    Ouverte(var pourcent) => $"ouverte a {pourcent} %",
};

// closed : implicitement abstraite, derivable directement dans cet assembly seulement.
public closed record Vanne;
public sealed record Fermee : Vanne;
public sealed record Ouverte(int Pourcent) : Vanne;

// Ajouter public sealed record Bloquee : Vanne; laisse compiler, avec un avertissement :
// warning CS8509: The switch expression does not handle all possible values of its input type
//   (it is not exhaustive). For example, the pattern 'Bloquee' is not covered.

// Deriver Vanne depuis un autre assembly :
// error CS9382: 'Bloquee': cannot use a closed type 'Vanne' from another assembly as a base type.

// SDK 11.0.100-rc.1.26425.128, net11.0, C# 15.
using System;
using System.Collections.Generic;
using System.Linq;

int[][] lots = [[3, 0, 5], [2, 4], [7, -1, 8], [9]];

// Un zero invalide le lot entier ; un negatif arrete tout.
externe: foreach (int[] lot in lots)
{
    int somme = 0;
    foreach (int n in lot)
    {
        if (n == 0) continue externe;
        if (n < 0) break externe;
        somme += n;
    }
    Console.WriteLine($"lot de {lot.Length} : {somme}");
}

// Un indexeur d'extension : une sequence s'indexe comme un tableau.
IEnumerable<int> impairs = Enumerable.Range(1, 10).Where(n => n % 2 == 1);
Console.WriteLine(impairs[2]);

// Sortie :
// lot de 2 : 6
// 5

public static class IndexeurSequence
{
    extension(IEnumerable<int> sequence)
    {
        public int this[int index] => sequence.ElementAt(index);
    }
}