C# 12 — les nouveautés qui changent le quotidien

C# 12 affine la productivité avec des primary constructors pour les classes, des collection expressions plus concises, et des paramètres par défaut pour les lambdas. Tu gagnes en lisibilité et en boilerplate en moins, tout en restant 100% compatible avec l’existant.

Fonctionnalités introduites

• Primary constructors sur les classes
• Collection expressions avec spread (..)
• Paramètres par défaut pour les lambdas
• Type alias (alias any type)
• InlineArray pour la performance (cas avancés)
• Améliorations diverses de pattern matching

Cas d’usage

Primary constructors pour les classes

Déclare et initialise tes propriétés à même la signature de classe. Idéal pour les types orientés données.

// Primary constructor on a class
public class Customer(string id, string name)
{
    // Property initializers use parameters from the primary constructor
    public string Id { get; } = id;
    public string Name { get; private set; } = name;

    // You can still add methods
    public void Rename(string newName)
    {
        // Validation logic remains explicit
        Name = string.IsNullOrWhiteSpace(newName) ? Name : newName;
    }
}

var c = new Customer("42", "Ada");
Console.WriteLine($"{c.Id} — {c.Name}");

Collection expressions plus concises

Construis des collections sans new/constructeurs verbeux. Lisible et rapide à écrire.

// Collection expressions
int[] numbers = [1, 2, 3];
List<string> names = ["Ada", "Grace"];
HashSet<int> evens = [2, 4, 6];

// Spread existing collections
var more = [..numbers, 4, 5];

// With LINQ projections
var squares = [..Enumerable.Range(1, 5).Select(n => n * n)];

Valeurs par défaut pour les lambdas

Rends tes fonctions utilitaires plus souples sans surcharger. Parfait pour la composition.

// Default values for lambda parameters
var format = (string s, int width = 8, char pad = '.') =>
{
    // Left pad to width using the pad character
    return s.PadLeft(width, pad);
};

Console.WriteLine(format("42"));
Console.WriteLine(format("42", 4, '0'));

Autres fonctionnalités

Alias de type (alias any type)

Donne un nom explicite à un type complexe et simplifie les signatures d'API.

// Type alias
using StringMap = System.Collections.Generic.Dictionary<string, string>;

StringMap headers = new() { ["Accept"] = "application/json" };

InlineArray (performance avancée)

Stocke un petit buffer dans une structure pour réduire les allocations (cas ciblés).

using System.Runtime.CompilerServices;

[InlineArray(16)]
public struct SmallBuffer
{
    private int _element0;
}

var buf = new SmallBuffer();

Raffinements de pattern matching

Des petits plus qui améliorent la lisibilité et les matchs sur types/constantes.

// Example placeholder
object x = 5;
var text = x switch { int i => $"int:{i}", _ => "other" };

Résumé

Adopte C# 12 sur les nouveaux modules pour réduire le bruit syntaxique et simplifier tes modèles de données. Migration progressive sans casse.

Avantages

• Moins de boilerplate (constructeurs + propriétés)
• Collections déclaratives faciles à lire
• APIs utilitaires plus flexibles avec lambdas

Inconvénients

• Nécessite un SDK .NET récent
• Primary constructors à utiliser avec parcimonie sur les grosses classes

Bonnes pratiques

• Réserve les primary constructors aux types centrés données
• Documente clairement les valeurs par défaut des lambdas
• Préserve la cohérence de style avec l’équipe