Procédure pas à pas : création et implémentation d’interfaces (Visual Basic)

Les interfaces décrivent les caractéristiques des propriétés, des méthodes et des événements, mais conservent les détails de l’implémentation aux structures ou aux classes.

Cette procédure pas à pas montre comment déclarer et implémenter une interface.

Remarque

Cette procédure pas à pas ne fournit pas d’informations sur la création d’une interface utilisateur.

Remarque

Votre ordinateur peut afficher différents noms ou emplacements pour certains des éléments de l’interface utilisateur Visual Studio dans les instructions suivantes. L’édition Visual Studio que vous avez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d’informations, consultez Personnaliser l’IDE.

Pour définir une interface

Ouvrez un nouveau projet d’application Windows Visual Basic.
Ajoutez un nouveau module au projet en cliquant sur Ajouter un module dans le menu Projet .
Nommez le nouveau module Module1.vb , puis cliquez sur Ajouter. Le code du nouveau module s’affiche.
Définissez une interface nommée TestInterface dans Module1 en tapant Interface TestInterface entre les instructions Module et End Module, puis en appuyant sur ENTRÉE. L’Éditeur de code met en retrait le Interface mot clé et ajoute une End Interface instruction pour former un bloc de code.
Définissez une propriété, une méthode et un événement pour l’interface en plaçant le code suivant entre les instructions Interface et End Interface.
```
Property Prop1() As Integer
Sub Method1(ByVal X As Integer)
Event Event1()
```

Implémentation

Vous remarquerez peut-être que la syntaxe utilisée pour déclarer des membres d’interface est différente de la syntaxe utilisée pour déclarer des membres de classe. Cette différence reflète le fait que les interfaces ne peuvent pas contenir de code d’implémentation.

Pour implémenter l’interface

Ajoutez une classe nommée ImplementationClass en ajoutant l’instruction suivante à Module1, après l’instruction End Interface , mais avant l’instruction End Module , puis en appuyant sur ENTRÉE :
```
Class ImplementationClass
```
Si vous travaillez dans l’environnement de développement intégré, l’Éditeur de code fournit une instruction correspondante End Class lorsque vous appuyez sur Entrée.
Ajoutez l’instruction suivante Implements à ImplementationClass, qui nomme l’interface que la classe implémente :
```
Implements TestInterface
```
Lorsqu’elle est répertoriée séparément d’autres éléments en haut d’une classe ou d’une structure, l’instruction Implements indique que la classe ou la structure implémente une interface.

Si vous travaillez dans l’environnement de développement intégré, l’Éditeur de code implémente les membres de classe requis par TestInterface lorsque vous appuyez sur Entrée, et vous pouvez ignorer l’étape suivante.
Si vous ne travaillez pas dans l’environnement de développement intégré, vous devez implémenter tous les membres de l’interface MyInterface. Ajoutez le code suivant à ImplementationClass pour implémenter Event1, Method1, et Prop1:
```
Event Event1() Implements TestInterface.Event1

Public Sub Method1(ByVal X As Integer) Implements TestInterface.Method1
End Sub

Public Property Prop1() As Integer Implements TestInterface.Prop1
    Get
    End Get
    Set(ByVal value As Integer)
    End Set
End Property
```
L’instruction Implements nomme l’interface et le membre de l’interface implémentés.
Terminez la définition de Prop1 en ajoutant un champ privé à la classe pour stocker la valeur de la propriété.
```
' Holds the value of the property.
Private pval As Integer
```
Retourne la valeur de pval à partir de l’accesseur get de la propriété.
```
Return pval
```
Définit la valeur de pval dans l’accesseur set de la propriété.
```
pval = value
```

Terminez la définition de Method1 en ajoutant le code suivant.

MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()

Pour tester l’implémentation de l’interface

Cliquez avec le bouton droit sur le formulaire de démarrage de votre projet dans l’Explorateur de solutions, puis cliquez sur Afficher le code. L’éditeur affiche la classe de votre formulaire de démarrage. Par défaut, le formulaire de démarrage est appelé Form1.
Ajoutez le champ suivant testInstance à la Form1 classe :
```
Dim WithEvents testInstance As TestInterface
```
En déclarant testInstance en tant que WithEvents, la Form1 classe peut gérer ses événements.
Ajoutez le gestionnaire d’événements suivant à la Form1 classe pour gérer les événements déclenchés par testInstance:
```
Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub
```

Ajoutez une sous-routine nommée Test à la Form1 classe pour tester la classe d’implémentation :

Sub Test()
    '  Create an instance of the class.
    Dim T As New ImplementationClass
    ' Assign the class instance to the interface.
    ' Calls to the interface members are 
    ' executed through the class instance.
    testInstance = T
    ' Set a property.
    testInstance.Prop1 = 9
    ' Read the property.
    MsgBox("Prop1 was set to " & testInstance.Prop1)
    '  Test the method and raise an event.
    testInstance.Method1(5)
End Sub

La Test procédure crée une instance de la classe qui implémente MyInterface, affecte cette instance au testInstance champ, définit une propriété et exécute une méthode via l’interface.

Ajoutez du code pour appeler la Test procédure à partir de la Form1 Load procédure de votre formulaire de démarrage :

Private Sub Form1_Load(ByVal sender As System.Object,
                       ByVal e As System.EventArgs) Handles MyBase.Load
    Test() ' Test the class.
End Sub

Exécutez la Test procédure en appuyant sur F5. Le message « Prop1 a été défini sur 9 » s’affiche. Une fois que vous avez cliqué sur OK, le message « Le paramètre X pour Method1 est 5 » s’affiche. Cliquez sur OK, et le message « Le gestionnaire d’événements a intercepté l’événement » s’affiche.

Voir aussi

Rétroaction

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

Last updated on 2025-06-19