Nouveau dans .NET 7 [9]: Surcharge des opérateurs dans les interfaces à partir de C# 11.0

Depuis la première version de C#, le langage de programmation a permis la surcharge des opérateurs. C# 11.0 introduit la possibilité de définir une surcharge d’opérateur dans une interface pour fournir une valeur par défaut ou un point commun entre les implémentations. Seulement puisque C# est 11.0 static abstract autorisé dans les interfaces.

Une interface avec un opérateur surchargé pourrait ressembler à ceci :

namespace de.WWWings;
 
public interface IFlug 
  where TSelf : IFlug
{
 string AbflugOrt { get; set; }
 double Auslastung { get; }
 DateTime Datum { get; set; }
 long FlugNr { get; set; }
 short FreiePlaetze { get; set; }
 bool Nichtraucherflug { get; set; }
 short Plaetze { get; set; }
 string Route { get; }
 string ZielOrt { get; set; }
 
 public static abstract Flug operator 
  +(TSelf flug, de.WWWings.PassagierSystem.Passagier pass);
}

L’un ou l’autre se demandera pourquoi l’interface doit être générique. La raison en est simple : vous finissez par en vouloir un Flug-Objet simplement avec + peut ajouter jusqu’à un passager. Sans l’implémentation générique, vous ne pourriez avoir qu’une variable de type IFlug ajouter au passager.

Enfin, l’implémentation de la classe nécessite toujours l’implémentation de l’interface : IFlug:

namespace de.WWWings
{
 
 public partial class Flug : IFlug
 {
  …
 
  /// 

  /// Operatorüberladung fuer die Buchung eines Flugs 
  /// durch Addition eines Flug- und eines Passagier-Objekts.
  /// 
  /// Flugobjekt
  /// Passagierobjekt
  /// Flugobjekt mit hinzugefügten Passagier
  public static Flug operator +(Flug flug,
                                PassagierSystem.Passagier pass)
  {
   pass.Buchen(flug);
   return flug;
  }
 
 }
}

(rme)