Interfaces (Guide de programmation C#)

  • Article

Mise à jour : novembre 2007

Les interfaces sont définies à l'aide du mot clé interface, comme illustré dans l'exemple suivant :

interface IEquatable<T>
{
    bool Equals(T obj);
}

Les interfaces décrivent un groupe de fonctionnalités connexes qui peuvent appartenir à n'importe quel class ou struct. Les interfaces peuvent être composées de méthodes, de propriétés, d'événements, d'indexeurs ou de toute combinaison de ces quatre types de membres. Une interface ne peut pas contenir de champs. Les membres d'interface sont automatiquement publics.

Lorsqu'on dit qu'une classe ou un struct hérite d'une interface, cela signifie que la classe ou le struct fournit une implémentation pour tous les membres définis par l'interface. L'interface elle-même ne procure aucune fonctionnalité qu'une classe ou un struct peut hériter, de la façon dont une fonctionnalité de classe de base peut être héritée. Toutefois, si une classe de base implémente une interface, la classe dérivée hérite de cette implémentation.

Les classes et les structures peuvent hériter d'interfaces de la même manière que les classes peuvent hériter d'une classe de base ou d'une structure, à deux exceptions près :

  • Une classe ou struct peut hériter de plusieurs interfaces.

  • Lorsqu'une classe ou une structure hérite une interface, elle hérite uniquement les noms de méthodes et les signatures, parce que l'interface elle-même ne contient aucune implémentation. Par exemple :

    public class Car : IEquatable<Car>
{
    public string Make {get; set;}
    public string Model { get; set; }
    public string Year { get; set; }

    // Implementation of IEquatable<T> interface
    public bool Equals(Car car)
    {
        if (this.Make == car.Make &&
            this.Model == car.Model &&
            this.Year == car.Year)
        {
            return true;
        }
        else
            return false;
    }
}

Pour implémenter un membre d'interface, le membre correspondant sur la classe doit être public, non static et avoir le même nom et la même signature que le membre d'interface. Les propriétés et les indexeurs sur une classe peuvent définir des accesseurs supplémentaires pour une propriété ou l'indexeur défini sur une interface. Par exemple, une interface peut déclarer une propriété avec un accesseur get, mais la classe qui implémente l'interface peut déclarer la même propriété avec un accesseur get et un accesseur set. Toutefois, si la propriété ou l'indexeur utilise l'implémentation explicite, les accesseurs doivent correspondre.

Les interfaces et les membres d'interface sont abstraits ; les interfaces ne fournissent pas d'implémentation par défaut. Pour plus d'informations, consultez Classes et membres de classe abstract et sealed.

L'interface IEquatable<T> annonce à l'utilisateur de l'objet que ce dernier peut déterminer s'il est égal à d'autres objets du même type, et l'utilisateur de l'interface n'a pas besoin de savoir comment cela est implémenté.

Les interfaces peuvent hériter d'autres interfaces. Il est possible pour une classe d'hériter plusieurs fois d'une interface, par l'intermédiaire de classes de base ou interfaces dont elle hérite. Dans ce cas, la classe ne peut implémenter l'interface qu'une seule fois, si elle est déclarée comme faisant partie de la nouvelle classe. Si l'interface héritée n'est pas déclarée dans le cadre de la nouvelle classe, son implémentation est fournie par la classe de base qui l'a déclarée. Il est possible pour une classe de base d'implémenter des membres d'interface à l'aide de membres virtuels - dans ce cas, la classe qui hérite de l'interface peut modifier le comportement de l'interface en substituant les membres virtuels. Pour plus d'informations sur les membres virtuels, consultez Polymorphisme.

Vue d'ensemble des interfaces

Une interface possède les propriétés suivantes :

  • Une interface est semblable à une classe de base abstraite : tout type non abstract qui hérite de l'interface doit implémenter tous ses membres.

  • Une interface ne peut pas être instanciée directement.

  • Les interfaces peuvent contenir des événements, des indexeurs, des méthodes et des propriétés.

  • Les interfaces ne contiennent aucune implémentation de méthodes.

  • Les classes et structs peuvent hériter d'une ou plusieurs interfaces.

  • Une d'interface peut elle-même hériter de plusieurs interfaces.

Dans cette section

Rubriques connexes

Voir aussi

Concepts

Guide de programmation C#

Référence

Héritage (Guide de programmation C#)