interface (Référence C#)

Une interface définit un contrat. Tout class ou struct qui implémente ce contrat doit fournir une implémentation des membres définis dans l’interface. À compter de C# 8.0, une interface peut définir une implémentation par défaut pour les membres. Il peut également définir des static membres afin de fournir une implémentation unique pour les fonctionnalités courantes.

Dans l’exemple suivant, la classe ImplementationClass doit implémenter une méthode nommée SampleMethod qui n’a aucun paramètre et qui retourne void.

Pour plus d’informations et d’exemples, consultez Interfaces.

Exemple d’interface

interface ISampleInterface
{
    void SampleMethod();
}

class ImplementationClass : ISampleInterface
{
    // Explicit interface member implementation:
    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }

    static void Main()
    {
        // Declare an interface instance.
        ISampleInterface obj = new ImplementationClass();

        // Call the member.
        obj.SampleMethod();
    }
}

Une interface peut être membre d’un espace de noms ou d’une classe. Une déclaration d’interface peut contenir des déclarations (signatures sans implémentation) des membres suivants :

Ces déclarations de membre précédentes ne contiennent généralement pas de corps. À compter de C# 8.0, un membre d’interface peut déclarer un corps. Il s’agit d’une implémentation par défaut. Les membres avec des corps permettent à l’interface de fournir une implémentation « par défaut » pour les classes et les structs qui ne fournissent pas d’implémentation de substitution. En outre, à compter de C# 8.0, une interface peut inclure :

À compter de C# 11, une interface peut déclarer static abstract des membres pour tous les types de membres à l’exception des champs. Cette fonctionnalité permet aux algorithmes génériques de spécifier le comportement de type nombre. Vous pouvez essayer cette fonctionnalité en utilisant le didacticiel sur les membres abstraits statiques dans les interfaces.

Les interfaces peuvent ne pas contenir d’état d’instance. Bien que les champs statiques soient désormais autorisés, les champs d’instance ne sont pas autorisés dans les interfaces. Les propriétés automatiques d’instance ne sont pas prises en charge dans les interfaces, car elles déclarent implicitement un champ masqué. Cette règle a un effet subtil sur les déclarations de propriété. Dans une déclaration d’interface, le code suivant ne déclare pas de propriété implémentée automatiquement comme dans un class ou struct. Au lieu de cela, elle déclare une propriété qui n’a pas d’implémentation par défaut, mais doit être implémentée dans n’importe quel type qui implémente l’interface :

public interface INamed
{
  public string Name {get; set;}
}

Une interface peut hériter d’une ou de plusieurs interfaces de base. Lorsqu’une interface remplace une méthode implémentée dans une interface de base, elle doit utiliser la syntaxe d’implémentation d’interface explicite.

Lorsqu’une liste de types de base contient une classe de base et des interfaces, la classe de base doit figurer en premier dans la liste.

Une classe qui implémente une interface peut implémenter explicitement les membres de cette interface. Un membre implémenté explicitement n’est pas accessible via une instance de classe, mais uniquement via une instance de l’interface. En outre, les membres de l’interface par défaut sont accessibles uniquement via une instance de l’interface.

Pour plus d’informations sur l’implémentation d’interface explicite, consultez Implémentation d’interface explicite.

Exemple d’implémentation d’interface

L’exemple suivant montre une implémentation d’interface. Dans cet exemple, l’interface contient la déclaration de propriété, et la classe contient l’implémentation. Toutes les instances d’une classe qui implémentent IPoint ont les propriétés entières x et y.

interface IPoint
{
   // Property signatures:
   int X
   {
      get;
      set;
   }

   int Y
   {
      get;
      set;
   }

   double Distance
   {
       get;
   }
}

class Point : IPoint
{
   // Constructor:
   public Point(int x, int y)
   {
      X = x;
      Y = y;
   }

   // Property implementation:
   public int X { get; set; }

   public int Y { get; set; }

   // Property implementation
   public double Distance =>
      Math.Sqrt(X * X + Y * Y);

}

class MainClass
{
   static void PrintPoint(IPoint p)
   {
      Console.WriteLine("x={0}, y={1}", p.X, p.Y);
   }

   static void Main()
   {
      IPoint p = new Point(2, 3);
      Console.Write("My Point: ");
      PrintPoint(p);
   }
}
// Output: My Point: x=2, y=3

spécification du langage C#

Pour plus d’informations, consultez la section Interfaces de la spécification du langage C# et la spécification de fonctionnalité pour les membres de l’interface par défaut - C# 8.0

Voir aussi