La nouvelle approche pour les opérateurs en C# 14

Depuis bien longtemps, C# autorise le développeur a substituer certains opérateurs. Bien que pratique, la syntaxe est un peu lourde et il arrive assez souvent que des bugs soient introduits par les développeurs (je pense notamment à la redéfinition de == ou != qui oublie certains cas et .. boom!)

Pour ceux qui préfèrent les explications en vidéo, c'est ici que ça se passe

Prenons un exemple très simple à comprendre. Considérons cette simple classe :

public class Periode(
    DateTime debut,
    DateTime fin)
{
    public DateTime Debut { get; } = debut;
    public DateTime Fin { get; private set; } = fin;

    public override string ToString()
    {
        return $"{Debut:dd/MM/yyyy} à {Fin:dd/MM/yyyy}";
    }
}

Admettons maintenant que l'on souhaite permettre d'ajouter/retirer des jours à cette période (c'est à dire pouvoir influer sur la date de fin). Bien entendu, il reste tout à fait possible d'avoir une approche qui se base sur les méthodes au sein même de notre classe, comme EntendrePeriode ou ReduirePeriode. Cependant, il peut être agréable d'autoriser syntaxiquement quelque chose comme :

var periode = new Periode(DateTime.Now, DateTime.Now.AddDays(7));
periode += 3;

Pour supporter ce scénario, nous avons l'approche historique de C# :

// A ajouter dans la classe Periode
public static Periode operator +(Periode p, int days)
{
    return new Periode(p.Debut, p.Fin.AddDays(days));
}

Et cela fonctionne aussi pour l'opérateur -. Cependant, quel souci y a-t-il avec cette approche ? On peut voir qu'une nouvelle instance est retournée... Dommage, un peu de gâchis de mémoire ici alors qu'on aurait pu modifier l'instance courante.

Avec C# 14, il est possible de créer l'opérateur au sein de la classe pour modifier sa valeur courante :

public void operator +=(int days)
{
    Fin = Fin.AddDays(days);
}
public void operator -=(int days)
{
    Fin = Fin.AddDays(-days);
}

L'avantage de cette approche est qu'il modifie l'instance courante. L'inconvénient de cette approche est qu'il modifier l'instance courante... Oui, l'immuabilité en informatique à des bons côtés pour éviter les effets de bord de nos modifications. Cependant, dans certains contexte où la mémoire est importante (comme au sein du framework par exemple?) cette nouvelle syntaxe, plus légère, est plutôt bienvenue.

Les deux syntaxes peuvent exister ensemble.

Et si dans la classe nous avons l'opérateur + qui a été redéfini ET l'opérateur C# 14 +=, c'est ce dernier qui aura la priorité lorsque += sera appelé.