C# moderne (12 → 15)

// Avant                                    // Après
var a = new List<int> { 1, 2, 3 };          List<int> a = [1, 2, 3];
var b = new int[] { };                      int[] b = [];
var c = new[] { 1, 2 }.Concat(autres);      int[] c = [1, 2, ..autres];   // ← étalement (spread)

// Fonctionne pour tout ce qui est « collection-compatible »
Span<byte> tampon = [0, 1, 2];
ImmutableArray<string> noms = ["Ada", "Alan"];
int[][] grille = [[1, 2], [3, 4]];

// C# 15 : passer des arguments au constructeur sous-jacent
List<string> grande = [with(capacity: 1000), .. source];
HashSet<string> insensible = [with(StringComparer.OrdinalIgnoreCase), "Bonjour", "BONJOUR"];
// → un seul élément : les deux chaînes sont égales pour ce comparateur

// --- 1. Motif de type, avec variable ---
if (forme is Cercle c) Console.WriteLine(c.Rayon);
if (o is not string) return;

// --- 2. switch expression (remplace 90 % des switch classiques) ---
decimal tarif = passager switch
{
    { Age: < 4 }                        => 0m,                    // motif de propriété
    { Age: < 18 } or { Statut: "etudiant" } => 5m,                // motifs logiques
    { Age: >= 65 }                      => 8m,                    // motif relationnel
    { Abonne: true, Age: >= 18 and < 65 } => 10m,                 // combinaison
    _                                   => 12m                     // cas par défaut
};

// --- 3. Motif avec déconstruction et garde when ---
var description = point switch
{
    (0, 0)                     => "origine",
    (var x, 0)                 => $"sur l'axe X à {x}",
    (0, var y)                 => $"sur l'axe Y à {y}",
    var (x, y) when x == y     => "sur la diagonale",
    _                          => "quelque part"
};

// --- 4. Motifs de liste (C# 11) ---
var analyse = segments switch
{
    []                     => "vide",
    [var seul]             => $"un seul : {seul}",
    ["api", .. var reste]  => $"appel API vers {string.Join('/', reste)}",
    [_, _, ..]             => "au moins deux segments"
};

// --- 5. Motif imbriqué dans une hiérarchie ---
string Etat(Commande cmd) => cmd switch
{
    { Statut: Statut.Payee, Livraison: { Transporteur: "DHL", Suivi: not null } } => "en route",
    { Statut: Statut.Payee } => "à expédier",
    { Statut: Statut.Annulee, Remboursement: null } => "à rembourser",
    _ => "en attente"
};

// namespace de fichier : un niveau d'indentation en moins dans TOUT le fichier
namespace Boutique.Domaine;

// using globaux : déclarés une fois pour tout le projet (GlobalUsings.cs)
global using Microsoft.EntityFrameworkCore;

// new implicite (target-typed)
Dictionary<string, List<int>> index = new();          // au lieu de répéter le type

// chaînes brutes : ni échappement, ni concaténation
var json = """
    { "nom": "Ada", "chemin": "C:\Temp\x" }
    """;
var requete = $$"""
    SELECT * FROM Clients WHERE Ville = '{{ville}}'
    """;

// interpolation et formatage
Console.WriteLine($"Total : {total:C} au {date:dd/MM/yyyy}");
Console.WriteLine($"{nom,-20}{prix,10:N2}");           // alignement en colonnes

// nameof : le nom d'un symbole, vérifié par le compilateur (résiste au renommage)
ArgumentNullException.ThrowIfNull(commande, nameof(commande));

// params collections (C# 13) : plus seulement des tableaux
static int Somme(params ReadOnlySpan<int> valeurs) { /* zéro allocation */ }
Somme(1, 2, 3);

// alias de n'importe quel type (C# 12)
using Coordonnees = (double Latitude, double Longitude);

public static class ExtensionsChaine
{
    // Ancienne syntaxe, toujours valable
    public static bool EstVide(this string s) => s.Length == 0;

    // Nouvelle syntaxe : un bloc pour un type receveur
    extension(string texte)
    {
        public bool EstEmail => texte.Contains('@');            // PROPRIÉTÉ d'extension
        public string Tronquer(int max) =>
            texte.Length <= max ? texte : texte[..max] + "…";   // méthode
    }

    extension(string)                                           // membres STATIQUES d'extension
    {
        public static string Vide => "";
        public static string DeChiffres(int n) => new('0', n);
    }
}

// Utilisation : comme si ces membres appartenaient à string
"a@b.fr".EstEmail            // true
"un texte très long".Tronquer(6)   // "un tex…"
string.DeChiffres(4)         // "0000"

// Affectation conditionnelle au null : n'affecte que si la cible n'est pas null
client?.Adresse = nouvelleAdresse;         // avant : if (client is not null) { ... }

// nameof sur un générique non lié
Console.WriteLine(nameof(List<>));         // "List"

// Modificateurs sur les paramètres de lambda
var essai = (out int r) => { r = 42; return true; };

// Opérateurs d'affectation composée définis par l'utilisateur (+= optimisé sans allocation)
public void operator +=(Vecteur autre) { X += autre.X; Y += autre.Y; }

public record class Chat(string Nom);
public record class Chien(string Nom);
public record class Oiseau(string Nom);

public union Animal(Chat, Chien, Oiseau);      // ← « exactement l'un des trois »

Animal a = new Chien("Rex");                   // conversion implicite

string nom = a switch                          // exhaustivité vérifiée : pas besoin de « _ »
{
    Chien d => d.Nom,
    Chat c  => c.Nom,
    Oiseau o => o.Nom
};

public closed record class EtatPorte;                     // dérivable seulement dans CET assembly
public record class Fermee : EtatPorte;
public record class Ouverte(float Pourcentage) : EtatPorte;

string Decrire(EtatPorte e) => e switch
{
    Fermee => "fermée",
    Ouverte(var p) => $"ouverte à {p} %"
    // aucun « _ » nécessaire : le compilateur connaît tous les descendants
};

exterieur: for (int l = 0; l < grille.Hauteur; l++)
{
    for (int c = 0; c < grille.Largeur; c++)
    {
        if (grille[l, c].Bloque) continue exterieur;   // passe à la ligne suivante
        if (grille[l, c].Arrivee) break exterieur;     // sort des DEUX boucles
    }
}
// Remplace les drapeaux booléens et les goto