12. Les interfaces

Contrairement aux classes abstraites, une interface est un groupe de membres complètement abstrait qui peut être considéré comme la définition d’un contrat : qui implémente une interface s’engage à écrire le code pour chaque méthode.

Cela signifie, en premier lieu, que toutes les méthodes et propriétés définies dans une interface sont implicitement abstraites, c’est-à-dire qu’il n’est pas possible de fournir leur implémentation dans l’interface elle-même. Pour créer une interface, le mot clé “interface” est utilisé :

public interface IExemple
{
  void Methode1();
  bool Methode2();

  string Propriete1 { get; set; }
  int Propriete2 { get; }
}

Dans cet exemple, nous avons suivi la convention selon laquelle les noms d’interface doivent commencer par la lettre majuscule I. Tout ce qui est déclaré dans une interface est public (et c’est une erreur d’indiquer le modificateur public).

Une interface ne peut pas contenir de variables, struct, enum et, comme déjà mentionné, d’implémentations de méthodes (éléments qui, au contraire, sont autorisées dans les classes abstraites).

Une interface est implémentée par une classe. Pour indiquer qu’une classe implémente une interface, en C# on utilise le caractère “:“, le même avec lequel on exprime l’héritage entre les classes (dans VB.NET on utilisele mot-clé Implements) :

public class Exemple : IExemple
{
  public void Methode1()
  {
    //...
  }

  public bool Methode2() { return true; }

  public string Proprieté1
  {
    get { return string.Empty; }
    set { /*...*/ }
  }

  public int Proprieté2
  {
    get { return 0; }
  }
}

Comme pour les classes abstraites, la classe qui implémente une interface doit fournir l’implémentation de toutes ses méthodes et propriétés, mais dans ce cas il n’y a pas besoin du mot-clé override, il suffit que les méthodes définies aient le même nom avec lequel elles sont déclarées dans l’interface.

Dans VB.NET, cependant, les noms attribués aux méthodes ne sont pas liés, car la méthode d’interface implémentée est explicitement indiquée.

Comme déjà vu, une classe peut hériter d’une seule classe de base, alors qu’elle peut implémenter un nombre illimité d’interfaces : dans ce cas, il est nécessaire de définir les méthodes et les propriétés de toutes les interfaces :

 public class Etudiant : Persona, IExemple1, IExemple2

Cette déclaration indique que la classe Étudiant étend Personne et implémente IExemple1 et IExemple2.

Supposons que IExemple1 et IExemple2 contiennent une méthode avec le même nom, par exemple une méthode void Calcule(). La classe Étudiant doit les définir tous les deux : pour éviter les conflits, les noms des méthodes doivent être précédés du nom de l’interface dans laquelle ils sont définis :

public void IExemple1.Calcule() { }

public void IExemple2.Calcule() { }

Une interface peut en hériter une autre : dans ce cas, la classe qui implémente l’interface héritée doit implémenter non seulement toutes ses méthodes et propriétés, mais aussi celles de l’interface de base.

Un objet qui implémente une interface peut également être utilisé dans toutes les parties du code où une telle interface est requise, de sorte que les interfaces définissent également une notion d’héritage.

Les interfaces et les classes abstraites sont utilisées pour définir une série de fonctionnalités de base qui doivent être implémentées par les classes qui les héritent ou les implémentent.

Le choix d’utiliser une interface ou une classe abstraite peut parfois être difficile. MSDN recommande :

“A travers les classes abstraites, les membres qui ont déjà été implémentés peuvent également être fournis. Par conséquent, avec une classe abstraite, il est possible de garantir une certaine quantité de fonctionnalités identiques, contrairement à ce qui se passe avec une interface (qui ne peut contenir aucune implémentation) […].

Si les entités à créer seront utilisées dans un large éventail d’objets différents, utilisez une interface. Les classes abstraites doivent être utilisées principalement pour les objets étroitement liés, tandis que les interfaces sont mieux adaptées pour fournir des fonctionnalités communes aux classes non apparentées. “

Précédent : 11. Les classes abstraites                                                                                                          Suivant : 14. Visual Studio 2017