Tout .NET 10 LTS

# 1. Le TFM
#    <TargetFramework>net8.0</TargetFramework> → net10.0
# 2. Les paquets Microsoft.* alignés sur 10.x
dotnet list package --outdated
# 3. Reconstruire en traitant les avertissements comme des erreurs
dotnet build -warnaserror
# 4. Passer les tests, puis lire les changements de comportement annoncés
dotnet test

public static class ExtensionsProduit
{
    extension(Produit produit)
    {
        // PROPRIÉTÉ d'extension : impossible avant C# 14
        public bool EstEnPromotion => produit.PrixBarre is not null;
        public decimal Economie => (produit.PrixBarre ?? produit.Prix) - produit.Prix;

        // Méthode, comme avant
        public string Etiquette() => produit.EstEnPromotion
            ? $"{produit.Nom} (-{produit.Economie:C})"
            : produit.Nom;
    }

    extension(Produit)          // membres STATIQUES d'extension
    {
        public static Produit Vide => new() { Nom = "(aucun)", Prix = 0 };
        public static Produit Depuis(string csv) => /* ... */ null!;
    }
}

// Utilisation : indistinguable d'un vrai membre du type
if (produit.EstEnPromotion) Console.WriteLine(produit.Etiquette());
var p = Produit.Depuis(ligne);

// Avant : déclarer, nommer et gérer le champ de soutien à la main
private string _reference = "";
public string Reference
{
    get => _reference;
    set => _reference = value.ToUpperInvariant();
}

// C# 14
public string Reference
{
    get;
    set => field = value.ToUpperInvariant();     // « field » = le champ généré
}

// Autre usage fréquent : initialisation paresseuse
public List<Ligne> Lignes => field ??= Charger();

// Affectation conditionnelle au null : n'affecte que si la cible existe
commande?.Adresse = nouvelleAdresse;
utilisateur?.Preferences?.Theme = "sombre";

// nameof sur un générique non lié
var nom = nameof(Dictionary<,>);          // "Dictionary"

// Modificateurs sur les paramètres de lambda (sans répéter les types)
var tryParse = (string s, out int r) => int.TryParse(s, out r);

// Conversions implicites vers Span : moins de surcharges à écrire
void Traiter(ReadOnlySpan<byte> donnees) { }
Traiter(monTableau);                       // conversion directe

// Constructeurs et événements partiels (utile aux générateurs de source)
public partial class Vue { public partial Vue(IService s); }

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

// LINQ : jointures externes de première classe (enfin)
var lignes = etudiants.LeftJoin(
    departements,
    e => e.DepartementId,
    d => d.Id,
    (e, d) => new { e.Nom, Departement = d?.Nom ?? "(aucun)" });
// RightJoin existe aussi — et EF Core 10 les traduit en SQL

// LINQ asynchrone intégré (plus de paquet System.Linq.Async)
var total = await flux.Where(x => x.Actif).SumAsync(x => x.Montant, ct);
var liste = await flux.Take(100).ToListAsync(ct);

// Comparaison de chaînes avec ordre numérique : "fichier2" < "fichier10"
var comparateur = StringComparer.Create(CultureInfo.CurrentCulture,
                                        CompareOptions.NumericOrdering);
noms.Sort(comparateur);

// System.Text.Json : options plus fines
var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
    AllowOutOfOrderMetadataProperties = true,      // JSON polymorphe plus tolérant
    RespectNullableAnnotations = true              // les annotations nullables sont honorées
};

// Cryptographie post-quantique (selon la plateforme) : ML-KEM, ML-DSA, SLH-DSA
// Utile pour les systèmes à longue durée de conservation des données chiffrées.

builder.Services.AddValidation();

public record CreerClient(
    [Required, StringLength(80, MinimumLength = 2)] string Nom,
    [Required, EmailAddress]                        string Email,
    [Range(18, 130)]                                int Age);

app.MapPost("/clients", (CreerClient dto) => TypedResults.Created("/clients/1", dto));
// Invalide → 400 + ProblemDetails par champ, sans une ligne de code de validation.
// Traverse les objets imbriqués et les collections ; annoter [ValidatableType] au besoin.
// Désactivation ponctuelle : .DisableValidation()

app.MapGet("/pouls", (CancellationToken ct) =>
{
    async IAsyncEnumerable<Mesure> Flux([EnumeratorCancellation] CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            yield return new Mesure(Random.Shared.Next(60, 100), DateTime.UtcNow);
            await Task.Delay(2000, ct);
        }
    }
    return TypedResults.ServerSentEvents(Flux(ct), eventType: "pouls");
});

// Fin de la double initialisation au prérendu : un attribut suffit
[PersistentState]
public List<Film>? Films { get; set; }

protected override async Task OnInitializedAsync()
    => Films ??= await Service.ChargerAsync();

// Table splitting : les colonnes vivent dans la table du propriétaire
mb.Entity<Client>(b =>
{
    b.ComplexProperty(c => c.AdresseLivraison);      // Adresse_Rue, Adresse_Ville…
    b.ComplexProperty(c => c.AdresseFacturation);    // optionnel accepté depuis EF 10
});

// Ou une seule colonne JSON, collections comprises
mb.Entity<Client>().ComplexProperty(c => c.Preferences, p => p.ToJson());

// Sémantique de VALEUR : ce qui échouait avec les owned types fonctionne
client.AdresseFacturation = client.AdresseLivraison;    // simple copie de propriétés
await db.SaveChangesAsync();

// ExecuteUpdate fonctionne aussi dans le JSON
await db.Blogs.ExecuteUpdateAsync(s =>
    s.SetProperty(b => b.Details.Vues, b => b.Details.Vues + 1), ct);

mb.Entity<Blog>()
  .HasQueryFilter("SuppressionLogique", b => !b.EstSupprime)
  .HasQueryFilter("Locataire", b => b.LocataireId == _locataire.Id);

var corbeille = await db.Blogs.IgnoreQueryFilters(["SuppressionLogique"]).ToListAsync(ct);

await db.Blogs.ExecuteUpdateAsync(s =>
{
    s.SetProperty(b => b.Vues, 8);
    if (nomChange) s.SetProperty(b => b.Nom, "nouveau");   // conditionnel : impossible avant
}, ct);

# Exécuter un simple fichier .cs, sans projet : idéal pour un script ou une démonstration
cat > bonjour.cs <<'EOF'
#:package Humanizer@2.14.1
Console.WriteLine(TimeSpan.FromMinutes(135).Humanize());
EOF
dotnet run bonjour.cs

# Et le convertir en vrai projet quand il grandit
dotnet project convert bonjour.cs

# Verbes CLI réorganisés (les anciennes formes fonctionnent toujours)
dotnet package add Serilog
dotnet package list --vulnerable
dotnet package search json

# Exécuter un outil sans l'installer durablement
dnx dotnet-ef -- migrations list