interface (référence C#)

Une interface contient uniquement les signatures des méthodes, des propriétés, des événements ou des indexeurs. Une classe ou struct qui implémente l'interface doit implémenter les membres de l'interface spécifiés dans la définition d'interface. Dans l'exemple suivant, la classe ImplementationClass doit implémenter une méthode nommée SampleMethod qui n'a pas de paramètres et retourne void.

Pour plus d'informations et d'exemples, consultez Interfaces (Guide de programmation C#).

Exemple

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, et peut contenir les signatures des membres suivants :

• Méthodes

• Propriétés

• Indexeurs

• Événements

Une interface peut hériter d'une ou de plusieurs interfaces de base.

Si une liste des types de base contient une classe de base et des interfaces, la classe de base doit apparaître en premier dans la liste.

Une classe qui implémente une interface peut implémenter de façon explicite des membres de cette interface. Lorsqu'un membre est implémenté de façon explicite, il n'est pas accessible via une instance de classe, mais uniquement via une instance de l'interface.

Pour d'autres détails et exemples de code sur des implémentations d'interface explicites, consultez Implémentation d'interface explicite (Guide de programmation C#).

L'exemple ci-après illustre l'implémentation d'une interface. Dans cet exemple, l'interface contient la déclaration de propriété et la classe, l'implémentation. Une instance d'une classe qui implémente IPoint a x et y propriétés entières.

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

   int y
   {
      get;
      set;
   }
}

class Point : IPoint
{
   // Fields: 
   private int _x;
   private int _y;

   // Constructor: 
   public Point(int x, int y)
   {
      _x = x;
      _y = y;
   }

   // Property implementation: 
   public int x
   {
      get
      {
         return _x;
      }

      set
      {
         _x = value;
      }
   }

   public int y
   {
      get
      {
         return _y;
      }
      set
      {
         _y = value;
      }
   }
}

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

   static void Main()
   {
      Point 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, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Référence

Mots clés C#

Types référence (référence C#)

Interfaces (Guide de programmation C#)

Utilisation de propriétés (Guide de programmation C#)

Utilisation d'indexeurs (Guide de programmation C#)

class (référence C#)

struct (Référence C#)

Interfaces (Guide de programmation C#)

Concepts

Guide de programmation C#

Autres ressources

Référence C#