Interfaces (Visual Basic)

Article
08/10/2011

Les interfaces définissent les propriétés, méthodes et événements qui peuvent être implémentés par les classes. Les interfaces vous permettent de définir des fonctionnalités sous forme de petits groupes de propriétés, méthodes et événements étroitement liés ; les risques d'incompatibilité s'en trouvent limités parce que vous avez la possibilité de développer des implémentations avancées sans détruire le code existant. Vous pouvez ajouter de nouvelles fonctionnalités à tout moment en développant des interfaces et implémentations supplémentaires.

Il existe plusieurs autres raisons qui peuvent vous amener à préférer les interfaces à l'héritage de classes :

Les interfaces sont mieux adaptées aux applications exigeant la création de nombreux types d'objets pas nécessairement liés pour assurer certaines fonctionnalités.
Les interfaces sont plus souples à utiliser que les classes de base, car il suffit de définir une seule implémentation pour pouvoir implémenter plusieurs interfaces.
Les interfaces sont plus indiquées lorsque vous n'avez pas besoin d'hériter une implémentation d'une classe de base.
Les interfaces sont utiles quand vous ne pouvez pas utiliser l'héritage de classes. Par exemple, les structures ne peuvent pas hériter des classes, mais elles peuvent implémenter des interfaces.

Déclaration d'interfaces

Les définitions d'interfaces sont comprises dans les instructions Interface et End Interface. À la suite de l'instruction Interface, vous pouvez ajouter une instruction Inherits facultative qui répertorie une ou plusieurs interfaces héritées. Les instructions Inherits doivent précéder toutes les autres instructions dans la déclaration, à l'exception des commentaires. Les autres instructions figurant dans la définition de l'interface doivent être Event, Sub, Function, Property, Interface, Class, Structure et Enum. Les interfaces ne peuvent pas contenir de code d'implémentation ni d'instructions associées au code d'implémentation, telles que End Sub ou End Property.

Dans un espace de noms, les instructions d'interface sont par défaut Friend, mais elles peuvent également être déclarées explicitement comme Public ou Friend. Les interfaces définies dans des classes, des modules, des interfaces et des structures sont par défaut Public, mais elles peuvent également être déclarées explicitement comme Public, Friend, Protected ou Private.

Notes

Le mot clé Shadows peut être appliqué à tous les membres d'interface. Le mot clé Overloads peut être appliqué aux instructions Sub, Function et Property déclarées dans une définition d'interface. Par ailleurs, les instructions Property peuvent posséder les modificateurs Default, ReadOnly ou WriteOnly. Aucun autre modificateur — Public, Private, Friend, Protected, Shared, Overrides, MustOverride ou Overridable — n'est autorisé. Pour plus d'informations, consultez Contextes de déclaration et niveaux d'accès par défaut (Visual Basic).

Par exemple, le code suivant définit une interface avec une fonction, une propriété et un événement.

Interface IAsset
    Event ComittedChange(ByVal Success As Boolean)
    Property Division() As String
    Function GetID() As Integer
End Interface

Implémentation d'interfaces

Le mot réservé Implements en Visual Basic est utilisé de deux manières. L'instruction Implements signifie qu'une classe ou une structure implémente une interface. Le mot clé Implements signifie qu'un membre de classe ou un membre de structure implémente un membre d'interface spécifique.

Implements, instruction

Si une classe ou une structure implémente une ou plusieurs interfaces, elle doit inclure l'instruction Implements juste après l'instruction Class ou Structure. L'implémentation de l'instruction Implements par une classe suppose l'existence d'une liste d'interfaces séparées par des virgules. La classe ou structure doit implémenter tous les membres d'interface à l'aide du mot clé Implements.

Implements, mot clé

L'implémentation du mot clé Implements suppose l'existence d'une liste de membres d'interfaces séparés par des virgules. En général, un seul membre d'interface est spécifié, mais vous pouvez tout à fait spécifier plusieurs membres. La spécification d'un membre d'interface se présente sous la forme du nom de l'interface (qui doit être spécifié dans une instruction implements dans la classe), suivi d'un point et du nom de la fonction membre, de la propriété ou de l'événement à implémenter. Le nom d'un membre qui implémente un membre d'interface peut utiliser n'importe quel identificateur conforme et ne doit pas obligatoirement respecter la convention InterfaceName_MethodName utilisée dans les versions antérieures de Visual Basic.

Par exemple, le code ci-dessous indique comment déclarer une sous-routine nommée Sub1 qui implémente une méthode d'une interface :

Class Class1
    Implements interfaceclass.interface2

    Sub Sub1(ByVal i As Integer) Implements interfaceclass.interface2.Sub1
    End Sub
End Class

Les types de paramètres et types de retour du membre qui implémente doivent correspondre à la propriété d'interface ou à la déclaration de membre dans l'interface. La façon la plus répandue d'implémenter un élément d'interface consiste à utiliser un membre portant le même nom que l'interface, comme dans l'exemple précédent.

Pour déclarer l'implémentation d'une méthode d'interface, vous pouvez utiliser tous les attributs conformes dans les déclarations de méthodes d'instances, notamment Overloads, Overrides, Overridable, Public, Private, Protected, Friend, Protected Friend, MustOverride, Default et Static. L'attribut Shared n'est pas conforme parce qu'il définit une classe au lieu d'une méthode d'instance.

Implements permet également d'écrire une seule méthode implémentant plusieurs méthodes définies dans une interface, comme dans l'exemple suivant :

Class Class2
    Implements I1, I2

    Protected Sub M1() Implements I1.M1, I1.M2, I2.M3, I2.M4
    End Sub
End Class

Vous pouvez utiliser un membre privé pour implémenter un membre d'interface. Lorsqu'un membre privé implémente un membre d'interface, ce membre devient disponible via l'interface, même s'il n'est pas directement disponible avec les variables objets pour la classe.

Exemples d'implémentation d'interface

Les classes qui implémentent une interface doivent implémenter toutes ses propriétés, méthodes et événements.

L'exemple à suivre définit deux interfaces. La seconde interface, Interface2, hérite de Interface1 et définit une propriété et une méthode supplémentaires.

Interface Interface1
    Sub sub1(ByVal i As Integer)
End Interface

' Demonstrates interface inheritance.
Interface Interface2
    Inherits Interface1
    Sub M1(ByVal y As Integer)
    ReadOnly Property Num() As Integer
End Interface

L'exemple suivant implémente Interface1, l'interface définie dans l'exemple précédent :

Public Class ImplementationClass1
    Implements Interface1
    Sub Sub1(ByVal i As Integer) Implements Interface1.sub1
        ' Insert code here to implement this method.
    End Sub
End Class

Ce dernier exemple implémente Interface2, y compris une méthode héritée de Interface1 :

Public Class ImplementationClass2
    Implements Interface2
    Dim INum As Integer = 0
    Sub sub1(ByVal i As Integer) Implements Interface2.sub1
        ' Insert code here that implements this method.
    End Sub
    Sub M1(ByVal x As Integer) Implements Interface2.M1
        ' Insert code here to implement this method.
    End Sub

    ReadOnly Property Num() As Integer Implements Interface2.Num
        Get
            Num = INum
        End Get
    End Property
End Class

Rubriques connexes

Titre	Description
Procédure pas à pas : création et implémentation d'interfaces (Visual Basic)	Fournit une procédure détaillée qui vous fait découvrir le processus de définition et d'implémentation de votre propre interface.
Variance dans les interfaces génériques (C# et Visual Basic)	Décrit la covariance et la contravariance dans les interfaces génériques et fournit une liste d'interfaces génériques variantes dans le .NET Framework.