Share via

Interfaces (Guide de programmation C#)

  • Article

Une interface contient les définitions pour un groupe de tâches connexes qu' classe ou struct peut implémenter.

En utilisant des interfaces, vous pouvez, par exemple, inclure le comportement de plusieurs sources dans une classe. Cette fonctionnalité est importante dans c car le langage ne prend pas en charge l'héritage multiple de classes. De plus, vous devez utiliser une interface si vous souhaitez simuler l'héritage pour les structs, car ils ne peuvent pas réellement hériter d'une structure ou d'une autre classe.

Vous définissez une interface à l'aide de le mot clé d' interface, comme indiqué dans l'exemple suivant.

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

Toute classe ou struct qui implémentent l'interface d' IEquatable doit contenir une définition d'une méthode d' Equals qui correspond à la signature que l'interface spécifie. Par conséquent, vous pouvez compter sur une classe qui implémente IEquatable<T> pour contenir une méthode d' Equals avec laquelle une instance de la classe peut déterminer si elle est égale à une autre instance de la même classe.

La définition d' IEquatable<T> ne fournit pas d'implémentation pour Equals. L'interface définit uniquement la signature. Ainsi, une interface en c est semblable à une classe abstraite dans laquelle toutes les méthodes sont abstraites. Toutefois, une classe ou une structure peut implémenter plusieurs interfaces, mais une classe peut hériter que d'une seule classe, digest ou pas. Par conséquent, à l'aide de les interfaces, vous pouvez inclure le comportement de plusieurs sources dans une classe.

Pour plus d'informations sur les classes abstraites, consultez l' Résumé et classes sealed et membres de classe.

Les interfaces peuvent contenir des méthodes, des propriétés, des événements, des indexeurs, ou toute combinaison de ces quatre types de membres. Pour des liens vers des exemples, consultez Rubriques connexes. Une interface ne peut pas contenir des constantes, des champs, des opérateurs, des constructeurs d'instance, des destructeurs, ou des types. Les membres d'interface sont automatiquement publics, et ils ne peuvent inclure les modificateurs d'accès. Les membres ne peuvent pas être statique.

Pour implémenter un membre d'interface, le membre correspondant de la classe d'implémentation doit être publique, non statique, et a les mêmes nom et signature que le membre d'interface.

Lorsqu'une classe ou une structure implémente une interface, la classe ou la structure doit fournir une implémentation pour tous les membres de l'interface définit. L'interface elle-même fournit pas de fonctionnalités qu'une classe ou une structure ne peut hériter de la sorte qu'elle peut hériter la fonctionnalité de classe de base. Toutefois, si une classe de base implémente une interface, une classe dérivée de la classe de base hérite cette implémentation.

L'exemple suivant illustre une implémentation de l'interface d'IEquatable<T> . La classe d'implémentation, Car, doit fournir une implémentation de la méthode d' Equals .

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

Les propriétés et les indexeurs d'une classe peuvent définir des utilisateurs supplémentaires pour une propriété ou un indexeur défini dans une interface. Par exemple, une interface peut déclarer une propriété qui possède un utilisateur d' get . La classe qui implémente l'interface peut déclarer la même propriété avec get et l'utilisateur d' définissez . Toutefois, si la propriété ou l'indexeur utilise l'implémentation explicite, les accesseurs doivent correspondre. Pour plus d'informations sur l'implémentation explicite, consultez Implémentation d'interface explicite (Guide de programmation C#) et l' Propriétés d'interface (Guide de programmation C#).

Les interfaces peuvent implémenter d'autres interfaces. Une classe peut inclure une interface plusieurs fois dans les classes de base qu'elle hérite de ou via les interfaces que d'autres interfaces implémentent. Toutefois, la classe peut fournir une implémentation d'une interface qu'une seule fois et uniquement si la classe déclare l'interface dans le cadre de la définition de la classe (class ClassName : InterfaceName). Si l'interface est hérité parce que vous avez hérité d'une classe de base qui implémente l'interface, la classe de base fournit l'implémentation des membres de l'interface. Toutefois, la classe dérivée peut implémenter de nouveau les membres d'interface au lieu d'utiliser l'implémentation héritée.

Une classe de base peut également implémenter les membres d'interface à l'aide de les membres virtuels. Dans ce cas, une classe dérivée peut modifier le comportement de l'interface en remplaçant les membres virtuels. Pour plus d'informations sur les membres virtuels, consultez Polymorphisme.

Interfaces récapitulatives

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

  • Une interface est semblable à une classe de base abstraite. Toute classe ou struct qui implémentent l'interface doit implémenter tous ses membres.

  • Une interface ne peut pas être instanciée directement. Ses membres sont implémentés par toute classe ou structure qui implémente l'interface.

  • 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.

  • Une classe ou une structure peut implémenter plusieurs interfaces. Une classe peut hériter d'une classe de base et également implémenter une ou plusieurs interfaces.

Dans cette section

Rubriques connexes

Chapitre proposé

Interfaces dans Formation du c 3,0 : Maîtrisez les notions de base du c 3,0

Voir aussi

Référence

Héritage (Guide de programmation C#)

Concepts

Guide de programmation C#