Interface, instruction (Visual Basic)

Déclare le nom d’une interface et introduit les définitions des membres que l’interface comprend.

Syntaxe

[ <attributelist> ] [ accessmodifier ] [ Shadows ] _  
Interface name [ ( Of typelist ) ]  
    [ Inherits interfacenames ]  
    [ [ modifiers ] Property membername ]  
    [ [ modifiers ] Function membername ]  
    [ [ modifiers ] Sub membername ]  
    [ [ modifiers ] Event membername ]  
    [ [ modifiers ] Interface membername ]  
    [ [ modifiers ] Class membername ]  
    [ [ modifiers ] Structure membername ]  
End Interface

Pièces

Terme	Définition
`attributelist`	Optionnel. Consultez la liste des attributs.
`accessmodifier`	Optionnel. Il peut s’agir de l’un des éléments suivants : - Public - Protégé - Ami - Privé - Ami protégé - Privé protégé Consultez les niveaux d’accès en Visual Basic.
`Shadows`	Optionnel. Voir Ombres.
`name`	Obligatoire. Nom de cette interface. Voir Noms d’éléments déclarés.
`Of`	Optionnel. Spécifie qu’il s’agit d’une interface générique.
`typelist`	Obligatoire si vous utilisez le mot clé Of . Liste des paramètres de type pour cette interface. Si vous le souhaitez, chaque paramètre de type peut être déclaré variant à l’aide `In` et `Out` aux modificateurs génériques. Consultez La liste des types.
`Inherits`	Optionnel. Indique que cette interface hérite des attributs et des membres d’une autre interface ou d’une autre interface. Voir l’instruction Inherits.
`interfacenames`	Obligatoire si vous utilisez l’instruction `Inherits` . Noms des interfaces à partir de lesquelles cette interface dérive.
`modifiers`	Optionnel. Modificateurs appropriés pour le membre d’interface défini.
`Property`	Optionnel. Définit une propriété membre de l’interface.
`Function`	Optionnel. Définit une `Function` procédure membre de l’interface.
`Sub`	Optionnel. Définit une `Sub` procédure membre de l’interface.
`Event`	Optionnel. Définit un événement membre de l’interface.
`Interface`	Optionnel. Définit une interface imbriquée dans cette interface. La définition de l’interface imbriquée doit se terminer par une `End Interface` instruction.
`Class`	Optionnel. Définit une classe membre de l’interface. La définition de classe membre doit se terminer par une `End Class` instruction.
`Structure`	Optionnel. Définit une structure membre de l’interface. La définition de la structure membre doit se terminer par une `End Structure` instruction.
`membername`	Obligatoire pour chaque propriété, procédure, événement, interface, classe ou structure définie en tant que membre de l’interface. Nom du membre.
`End Interface`	Met fin à la `Interface` définition.

Remarques

Une interface définit un ensemble de membres, tels que les propriétés et les procédures, que les classes et les structures peuvent implémenter. L’interface définit uniquement les signatures des membres et non leurs fonctions internes.

Une classe ou une structure implémente l’interface en fournissant du code pour chaque membre défini par l’interface. Enfin, lorsque l’application crée une instance à partir de cette classe ou structure, un objet existe et s’exécute en mémoire. Pour plus d’informations, consultez Objets et classes et interfaces.

Vous ne pouvez utiliser Interface qu’au niveau de l’espace de noms ou du module. Cela signifie que le contexte de déclaration d’une interface doit être un fichier source, un espace de noms, une classe, une structure, un module ou une interface, et ne peut pas être une procédure ou un bloc. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

Interfaces par défaut pour l’accès Friend . Vous pouvez ajuster leurs niveaux d’accès avec les modificateurs d’accès. Pour plus d’informations, consultez Niveaux d’accès en Visual Basic.

Règles

Interfaces d’imbrication. Vous pouvez définir une interface dans une autre. L’interface externe est appelée interface conteneur et l’interface interne est appelée interface imbriquée.
Déclaration de membre. Lorsque vous déclarez une propriété ou une procédure en tant que membre d’une interface, vous définissez uniquement la signature de cette propriété ou procédure. Cela inclut le type d’élément (propriété ou procédure), ses paramètres et ses types de paramètres et son type de retour. En raison de cela, la définition de membre utilise une seule ligne de code et termine les instructions telles que End Function ou End Property ne sont pas valides dans une interface.

En revanche, lorsque vous définissez une énumération ou une structure, ou une classe ou une interface imbriquée, il est nécessaire d’inclure leurs membres de données.
Modificateurs de membre. Vous ne pouvez pas utiliser de modificateurs d’accès lors de la définition des membres du module, ni spécifier un modificateur de procédure partagé ou n’importe quel modificateur de procédure, à l’exception des surcharges. Vous pouvez déclarer n’importe quel membre avec Shadows, et vous pouvez utiliser Default lors de la définition d’une propriété, ainsi que ReadOnly ou WriteOnly.
Héritage. Si l’interface utilise l’instruction Inherits, vous pouvez spécifier une ou plusieurs interfaces de base. Vous pouvez hériter de deux interfaces même si elles définissent chacun un membre portant le même nom. Si vous le faites, le code d’implémentation doit utiliser la qualification de nom pour spécifier le membre qu’il implémente.

Une interface ne peut pas hériter d’une autre interface avec un niveau d’accès plus restrictif. Par exemple, une Public interface ne peut pas hériter d’une Friend interface.

Une interface ne peut pas hériter d’une interface imbriquée dans celle-ci.
Mise en œuvre. Lorsqu’une classe utilise l’instruction Implements pour implémenter cette interface, elle doit implémenter chaque membre défini dans l’interface. En outre, chaque signature dans le code d’implémentation doit correspondre exactement à la signature correspondante définie dans cette interface. Toutefois, le nom du membre dans le code d’implémentation n’a pas besoin de correspondre au nom du membre tel qu’il est défini dans l’interface.

Lorsqu’une classe implémente une procédure, elle ne peut pas désigner la procédure comme Shared.
Propriété par défaut. Une interface peut spécifier au plus une propriété comme propriété par défaut, qui peut être référencée sans utiliser le nom de la propriété. Vous spécifiez une telle propriété en la déclarant avec le modificateur par défaut .

Notez que cela signifie qu’une interface peut définir une propriété par défaut uniquement si elle hérite d’aucun.

Comportement

Niveau d’accès. Tous les membres de l’interface disposent implicitement d’un accès public . Vous ne pouvez pas utiliser de modificateur d’accès lors de la définition d’un membre. Toutefois, une classe implémentant l’interface peut déclarer un niveau d’accès pour chaque membre implémenté.

Si vous affectez une instance de classe à une variable, le niveau d’accès de ses membres peut dépendre du type de données de la variable ou de la classe d’implémentation. L’exemple suivant illustre cela.
```
Public Interface IDemo
    Sub DoSomething()
End Interface
Public Class implementIDemo
    Implements IDemo
    Private Sub DoSomething() Implements IDemo.DoSomething
    End Sub
End Class
Dim varAsInterface As IDemo = New implementIDemo()
Dim varAsClass As implementIDemo = New implementIDemo()
```
Si vous accédez aux membres de classe via varAsInterface, ils disposent tous d’un accès public. Toutefois, si vous accédez aux membres via varAsClass, la Sub procédure doSomething a un accès privé.
Portée. Une interface est dans l’étendue de son espace de noms, de sa classe, de sa structure ou de son module.

L’étendue de chaque membre d’interface est l’interface entière.
Durée de vie. Une interface n’a pas elle-même de durée de vie, ni ses membres. Lorsqu’une classe implémente une interface et qu’un objet est créé en tant qu’instance de cette classe, l’objet a une durée de vie dans l’application dans laquelle il est en cours d’exécution. Pour plus d’informations, consultez « Durée de vie » dans l’instruction Class.

Exemple :

L’exemple suivant utilise l’instruction Interface pour définir une interface nommée thisInterface, qui doit être implémentée avec une Property instruction et une Function instruction.

Public Interface thisInterface
    Property ThisProp(ByVal thisStr As String) As Char
    Function ThisFunc(ByVal thisInt As Integer) As Integer
End Interface

Notez que les instructions et Function les Property instructions n’introduisent pas de blocs se terminant par End Property et End Function dans l’interface. L’interface définit uniquement les signatures de ses membres. Les blocs complets PropertythisInterfaceapparaissent Function dans une classe qui implémente .

Voir aussi

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-07-31