Interfaces (Visual Basic)

Les interfaces définissent les propriétés, les méthodes et les événements que les classes peuvent implémenter. Les interfaces vous permettent de définir des fonctionnalités en tant que petits groupes de propriétés, méthodes et événements étroitement liés ; cela réduit les problèmes de compatibilité, car vous pouvez développer des implémentations améliorées pour vos interfaces sans compromettre le code existant. Vous pouvez ajouter de nouvelles fonctionnalités à tout moment en développant des interfaces et des implémentations supplémentaires.

Il existe plusieurs autres raisons pour lesquelles vous souhaiterez peut-être utiliser des interfaces au lieu de l’héritage de classe :

• Les interfaces sont mieux adaptées aux situations dans lesquelles vos applications nécessitent de nombreux types d’objets éventuellement non liés pour fournir certaines fonctionnalités.

• Les interfaces sont plus flexibles que les classes de base, car vous pouvez définir une implémentation unique qui peut implémenter plusieurs interfaces.

• Les interfaces sont meilleures dans les situations où vous n’avez pas besoin d’hériter de l’implémentation d’une classe de base.

• Les interfaces sont utiles lorsque vous ne pouvez pas utiliser l’héritage de classe. Par exemple, les structures ne peuvent pas hériter de classes, mais elles peuvent implémenter des interfaces.

Déclaration des interfaces

Les définitions d’interface sont placées entre les instructions et End Interface les Interface instructions. Après l’instruction Interface , vous pouvez ajouter une instruction facultative Inherits qui répertorie une ou plusieurs interfaces héritées. Les Inherits instructions doivent précéder toutes les autres instructions de la déclaration, à l’exception des commentaires. Les instructions restantes dans la définition de l’interface doivent être Event, , PropertyFunctionSub, Interface, , Classet StructureEnum les instructions. Les interfaces ne peuvent pas contenir de code ou d’instructions d’implémentation associés au code d’implémentation, comme End Sub ou End Property.

Dans un espace de noms, les instructions d’interface sont Friend par défaut, mais elles peuvent également être déclarées explicitement en tant que Public ou Friend. Les interfaces définies dans les classes, les modules, les interfaces et les structures sont Public par défaut, mais elles peuvent également être déclarées explicitement en tant que Public, Friend, ou ProtectedPrivate.

Remarque

Le Shadows mot clé peut être appliqué à tous les membres de l’interface. Le Overloads mot clé peut être appliqué à Sub, Functionet Property les instructions déclarées dans une définition d’interface. En outre, les Property instructions peuvent avoir les modificateurs ou ReadOnlyWriteOnly les Defaultmodificateurs. Aucun des autres modificateurs —Public, , Private, ProtectedFriend, SharedOverrides, , MustOverrideou Overridable— n’est autorisé. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

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 des interfaces

Le mot Implements réservé Visual Basic est utilisé de deux façons. L’instruction Implements signifie qu’une classe ou une structure implémente une interface. Le Implements mot clé signifie qu’un membre de classe ou un membre de structure implémente un membre d’interface spécifique.

Implémente l’instruction

Si une classe ou une structure implémente une ou plusieurs interfaces, elle doit inclure l’instruction Implements immédiatement après l’instruction ou Structure l’instructionClass. L’instruction Implements nécessite une liste séparée par des virgules d’interfaces à implémenter par une classe. La classe ou la structure doit implémenter tous les membres de l’interface à l’aide du Implements mot clé.

Implémente le mot clé

Le Implements mot clé nécessite une liste séparée par des virgules des membres de l’interface à implémenter. En règle générale, seul un seul membre d’interface est spécifié, mais vous pouvez spécifier plusieurs membres. La spécification d’un membre d’interface se compose du nom de l’interface, qui doit être spécifié dans une instruction implémente dans la classe ; une période ; et le 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 juridique, et il n’est pas limité à la InterfaceName_MethodName convention utilisée dans les versions antérieures de Visual Basic.

Par exemple, le code suivant montre comment déclarer une sous-routine nommée Sub1 qui implémente une méthode d’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 les types de retour du membre implémentant doivent correspondre à la propriété d’interface ou à la déclaration de membre dans l’interface. La façon la plus courante d’implémenter un élément d’une interface est avec un membre portant le même nom que l’interface, comme indiqué dans l’exemple précédent.

Pour déclarer l’implémentation d’une méthode d’interface, vous pouvez utiliser tous les attributs qui sont légaux sur les déclarations de méthode d’instance, notamment , , , , Protected FriendProtectedFriendPublicPrivateOverridable, .StaticDefaultMustOverrideOverridesOverloads L’attribut Shared n’est pas légal, car il définit une classe plutôt qu’une méthode d’instance.

En utilisant Implements, vous pouvez également écrire une méthode unique qui implémente 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’une interface, ce membre devient disponible par le biais de l’interface, même s’il n’est pas disponible directement sur les variables d’objet 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 suivant définit deux interfaces. La deuxième interface, hérite Interface2Interface1 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

L’exemple final 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

Vous pouvez implémenter une propriété readonly avec une propriété readwrite (autrement dit, vous n’avez pas besoin de la déclarer en lecture seule dans la classe d’implémentation). L’implémentation d’une interface promet d’implémenter au moins les membres déclarés par l’interface, mais vous pouvez offrir davantage de fonctionnalités, comme permettre à votre propriété d’être accessible en écriture.

Rubriques connexes

Titre	Descriptif
Procédure pas à pas : création et implémentation d’interfaces	Fournit une procédure détaillée qui vous guide tout au long du processus de définition et d’implémentation de votre propre interface.
Variance dans les interfaces génériques	Décrit la covariance et la contravariance dans les interfaces génériques et fournit une liste d’interfaces génériques de variantes dans le .NET Framework.