interface (C#)

Référence du langage C#

interface (Référence C#)

Une interface contient uniquement les signatures de méthodes, délégués ou événements. L'implémentation des méthodes se fait dans la classe qui implémente l'interface, comme illustré dans l'exemple suivant :

      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();
    }
}

Notes

Une interface peut être un membre d'un espace de noms ou d'une classe, et peut contenir les signatures des membres suivants :

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, par exemple, 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#).

Exemple

L'exemple ci-après illustre l'implémentation d'une interface. Dans cet exemple, l'interface IPoint contient la déclaration de propriété, qui a pour rôle de définir et d'obtenir les valeurs des champs. La classe Point contient l'implémentation de la propriété.

// keyword_interface_2.cs
// Interface implementation
using System;
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);
   }
}

Sortie


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

Sortie

Référence

Concepts

Autres ressources