Tout .NET 11 aperçu

public record class Succes(Commande Commande);
public record class StockInsuffisant(string Reference, int Disponible);
public record class PaiementRefuse(string Motif);

public union ResultatCommande(Succes, StockInsuffisant, PaiementRefuse);

// Conversion implicite depuis chaque cas
ResultatCommande r = new StockInsuffisant("AB-1234", 2);

// Le compilateur VÉRIFIE que tous les cas sont traités : pas besoin de « _ »
IResult reponse = r switch
{
    Succes s            => Results.Created($"/commandes/{s.Commande.Id}", s.Commande),
    StockInsuffisant si => Results.Conflict(new { si.Reference, si.Disponible }),
    PaiementRefuse pr   => Results.Problem(pr.Motif, statusCode: 402)
};

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 avertissement : le compilateur connaît tous les descendants directs
};

// --- Arguments dans une expression de collection ---
string[] valeurs = ["un", "deux", "trois"];
List<string> liste = [with(capacity: valeurs.Length * 2), .. valeurs];
HashSet<string> sansCasse = [with(StringComparer.OrdinalIgnoreCase), "Bonjour", "BONJOUR"];
// → un seul élément : les deux chaînes sont égales pour ce comparateur

// --- Indexeurs d'extension ---
public static class IndexeurSequence
{
    extension(IEnumerable<int> sequence)
    {
        public int this[int index] => sequence.ElementAt(index);
    }
}
IEnumerable<int> nombres = Enumerable.Range(1, 10);
int troisieme = nombres[2];              // indexation sur un IEnumerable

// --- break / continue étiquetés ---
exterieur: for (int l = 0; l < grille.Hauteur; l++)
{
    for (int c = 0; c < grille.Largeur; c++)
    {
        if (grille[l, c].Bloque) continue exterieur;
        if (grille[l, c].Arrivee) break exterieur;
    }
}
// Remplace les drapeaux booléens et les goto ; une règle d'analyse (IDE0410) les signale

// --- Sécurité mémoire, première étape ---
// Déclarer un pointeur, prendre une adresse, utiliser fixed / stackalloc / sizeof
// ne nécessite plus de contexte « unsafe » ; DÉRÉFÉRENCER, si.
int nombre = 42;
int* pointeur = &nombre;                 // autorisé hors unsafe
// Console.WriteLine(*pointeur);          // ← nécessite toujours unsafe

public sealed class EmailUniqueAttribute : AsyncValidationAttribute
{
    // La version synchrone est abstraite : on l'interdit explicitement
    protected override ValidationResult? IsValid(object? valeur, ValidationContext ctx) =>
        throw new InvalidOperationException("Utiliser IsValidAsync.");

    protected override async Task<ValidationResult?> IsValidAsync(
        object? valeur, ValidationContext ctx, CancellationToken ct)
    {
        var utilisateurs = ctx.GetRequiredService<IServiceUtilisateur>();
        return valeur is string email && await utilisateurs.EmailExisteAsync(email, ct)
            ? new ValidationResult("Cet email est déjà enregistré.")
            : ValidationResult.Success;
    }
}

public record Inscription([Required, EmailAddress, EmailUnique] string Email);

builder.Services.AddValidation();
app.MapPost("/inscriptions", (Inscription dto) => Results.Ok(dto));
// La vérification en base a lieu AVANT l'entrée dans ton code, sans bloquer de thread.
// Les validateurs indépendants s'exécutent en parallèle quand c'est possible.

// Types complexes et colonnes JSON compatibles avec l'héritage TPT / TPC
mb.Entity<Animal>().UseTptMappingStrategy()
                   .ComplexProperty(a => a.Details, b => b.ToJson());

// Configuration d'une propriété imbriquée par simple chaînage
mb.Entity<MonEntite>().Property(e => e.Details.Description).HasMaxLength(500);

// Clés et index sur des propriétés de types complexes, y compris dans le JSON
mb.Entity<Client>().HasKey(c => c.ClientId.Valeur);
mb.Entity<Client>().HasIndex(c => c.Adresse.CodePostal);
mb.Entity<Commande>().HasIndex("Lignes[].Reference");     // dans une collection JSON

// FullJoin traduit en FULL JOIN
var tout = await db.Clients.FullJoin(db.Commandes,
    c => c.Id, o => o.ClientId, (c, o) => new { Client = c, Commande = o }).ToListAsync(ct);

// MaxBy / MinBy traduits en SQL
var plusActif = await db.Blogs.MaxByAsync(b => b.Billets.Count(), ct);

// Relation EF sans contrainte en base (bases héritées, synchronisation de données)
mb.Entity<Blog>().HasMany(b => b.Billets).WithOne(p => p.Blog)
  .HasForeignKey(p => p.BlogId).ExcludeForeignKeyFromMigrations();

// Colonnes de période d'une table temporelle mappées à de vraies propriétés CLR
mb.Entity<Employe>().ToTable("Employes", t => t.IsTemporal(p =>
{
    p.HasPeriodStart(e => e.DebutPeriode);
    p.HasPeriodEnd(e => e.FinPeriode);
}));

// Index vectoriel géré par les migrations
mb.Entity<Blog>().HasVectorIndex(b => b.Embedding, "cosine");

// Recherche approximative (rapide) au lieu d'un calcul exact sur toutes les lignes
var proches = await db.Blogs
    .VectorSearch(b => b.Embedding, vecteurRequete, "cosine")
    .OrderBy(r => r.Distance)
    .Take(5)
    .WithApproximate()
    .ToListAsync(ct);

// Catalogue et index plein texte créés par migration (fini le SQL manuel)
mb.HasFullTextCatalog("ftCatalog");
mb.Entity<Article>().HasFullTextIndex(a => a.Contenu).UseCatalog("ftCatalog");

// Fonctions table avec score de pertinence
var pertinents = await db.Articles.FreeTextTable("clavier mécanique", a => a.Contenu)
    .OrderByDescending(r => r.Rank)
    .Select(r => r.Value)
    .ToListAsync(ct);

// JSON_CONTAINS sur SQL Server 2025 (au lieu d'OPENJSON) et index JSON
// EF.Functions.JsonContains(...), EF.Functions.JsonPathExists(...)

# Créer ET appliquer en une commande (compilation Roslyn à l'exécution)
dotnet ef database update AjoutProduits --add

# Fichier de configuration : plus besoin de répéter --project et --startup-project
cat .config/dotnet-ef.json
# { "project": "src/App.Infrastructure", "startupProject": "src/App.Api", "context": "AppDbContext" }

# Joker sur les contextes multiples
dotnet ef migrations list --context "*"

# Suppression hors connexion, ou avec une chaîne explicite
dotnet ef migrations remove --offline
dotnet ef database drop --connection "Server=test;..." --force

# Installer l'aperçu à côté de .NET 10 (les SDK cohabitent sans conflit)
# → https://dotnet.microsoft.com/download/dotnet/11.0

# Épingler la version par projet pour ne pas basculer toute la machine
cat > global.json <<'EOF'
{ "sdk": { "version": "11.0.100-preview.6", "rollForward": "latestPreview" } }
EOF

# Une branche dédiée, un TFM modifié, et on regarde ce qui casse
# <TargetFramework>net11.0</TargetFramework>
dotnet build -warnaserror
dotnet test