interface (référence C#)interface (C# Reference)

Une interface contient uniquement des signatures de méthodes, de propriétés, d’événements ou d’indexeurs.An interface contains only the signatures of methods, properties, events or indexers. Une classe ou un struct qui implémente l’interface doit implémenter les membres de l’interface qui sont spécifiés dans la définition de l’interface.A class or struct that implements the interface must implement the members of the interface that are specified in the interface definition. 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.In the following example, class ImplementationClass must implement a method named SampleMethod that has no parameters and returns void.

Pour plus d’informations et d’exemples, consultez Interfaces.For more information and examples, see Interfaces.

ExempleExample

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 :An interface can be a member of a namespace or a class and can contain signatures of the following members:

Une interface peut hériter d’une ou de plusieurs interfaces de base.An interface can inherit from one or more base interfaces.

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.When a base type list contains a base class and interfaces, the base class must come first in the list.

Une classe qui implémente une interface peut implémenter explicitement les membres de cette interface.A class that implements an interface can explicitly implement members of that interface. Un membre implémenté explicitement n’est pas accessible via une instance de classe, mais uniquement via une instance de l’interface.An explicitly implemented member cannot be accessed through a class instance, but only through an instance of the interface.

Pour plus d’informations et plus d’exemples sur l’implémentation explicite des interfaces, consultez Implémentation d’interface explicite.For more details and code examples on explicit interface implementation, see Explicit Interface Implementation.

ExempleExample

L’exemple suivant montre une implémentation d’interface.The following example demonstrates interface implementation. Dans cet exemple, l’interface contient la déclaration de propriété, et la classe contient l’implémentation.In this example, the interface contains the property declaration and the class contains the implementation. Toutes les instances d’une classe qui implémentent IPoint ont les propriétés entières x et y.Any instance of a class that implements IPoint has integer properties x and y.

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()
   {
      IPoint p = new Point(2, 3);
      Console.Write("My Point: ");
      PrintPoint(p);
   }
}
// Output: My Point: x=2, y=3

spécification du langage C#C# language specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also