interface (Référence C#)

Mise à jour : novembre 2007

Une interface contient uniquement les signatures de méthodes, propriétés, événements ou indexeurs. L'implémentation des membres se fait dans la classe ou le struct qui implémente l'interface, comme le montre l'exemple suivant :

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.

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, consultez les sections suivantes dans Spécifications du langage C#.

• 1,9 Interfaces

• 3.4.5 Membres d'interface

• 4.2.4 Types interface

• 10.1.2.2 Implémentations d'interface

• 11.2 Interfaces de struct

• 13 Interfaces

Voir aussi

Concepts

Guide de programmation C#

Référence

Mots clés C#

Types référence (Référence 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#)

Autres ressources

Référence C#