Procedura dettagliata: creazione e implementazione di interfacce (Visual Basic)

Articolo
08/11/2011

Le interfacce descrivono le caratteristiche di proprietà, metodi ed eventi, mentre i dettagli relativi all'implementazione sono definiti attraverso strutture o classi.

In questa procedura dettagliata viene illustrato come dichiarare e implementare un'interfaccia.

Nota

Nel computer in uso è possibile che vengano visualizzati nomi o percorsi diversi per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per ulteriori informazioni vedere Impostazioni di Visual Studio.

Per definire un'interfaccia

Aprire un nuovo progetto Applicazione Windows di Visual Basic.
Aggiungere un nuovo modulo al progetto scegliendo Aggiungi modulo dal menu Progetto.
Assegnare al nuovo modulo il nome Module1.vb e scegliere Aggiungi. Verrà visualizzato il codice del nuovo modulo.
Definire un'interfaccia denominata TestInterface in Module1 digitando Interface TestInterface tra le istruzioni Module ed End Module, quindi premere INVIO. Nell'editor di codice verranno inseriti rientri nella parola chiave Interface e verrà aggiunta un'istruzione End Interface per formare un blocco di codice.
Definire una proprietà, un metodo e un evento per l'interfaccia inserendo tra le istruzioni Interface ed End Interface il seguente codice:
```
Property Prop1() As Integer
Sub Method1(ByVal X As Integer)
Event Event1()
```

Implementazione

La sintassi utilizzata per dichiarare membri di interfaccia è diversa da quella utilizzata per dichiarare membri di classe. La differenza è dovuta al fatto che le interfacce non possono contenere codice di implementazione.

Per implementare l'interfaccia

Aggiungere una classe denominata ImplementationClass aggiungendo l'istruzione riportata di seguito a Module1 dopo l'istruzione End Interface ma prima dell'istruzione End Module, quindi premere INVIO:
```
Class ImplementationClass
```
Se si utilizza l'ambiente di sviluppo integrato (IDE), nell'editor di codice viene fornita un'istruzione End Class corrispondente quando viene premuto INVIO.
Aggiungere la seguente istruzione Implements a ImplementationClass per assegnare un nome all'interfaccia implementata dalla classe:
```
Implements TestInterface
```
Quando elencata separatamente da altri elementi all'inizio di una classe o di una struttura, l'istruzione Implements indica che la classe o la struttura implementa un'interfaccia.

Se si utilizza l'ambiente di sviluppo integrato, nell'editor di codice vengono implementati i membri di classe richiesti da TestInterface quando viene premuto INVIO. È quindi possibile ignorare il passaggio successivo.
Se non si utilizza l'ambiente di sviluppo integrato, è necessario implementare tutti i membri dell'interfaccia MyInterface. Aggiungere il seguente codice a ImplementationClass per implementare Event1, Method1 e 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'istruzione Implements assegna un nome all'interfaccia e al membro di interfaccia implementati.
Completare la definizione di Prop1 aggiungendo un campo privato alla classe in cui è stato memorizzato il valore della proprietà:
```
' Holds the value of the property.
Private pval As Integer
```
Restituire il valore di pval dalla funzione di accesso get della proprietà.
```
Return pval
```
Impostare il valore di pval nella funzione di accesso set della proprietà.
```
pval = value
```
Completare la definizione di Method1 aggiungendo il seguente codice:
```
MsgBox("The X parameter for Method1 is " & X)
RaiseEvent Event1()
```

Per testare l'implementazione dell'interfaccia

Fare clic con il pulsante destro del mouse sul form di avvio del progetto in Esplora soluzioni, quindi scegliere Visualizza codice. Verrà visualizzata la classe del form di avvio. Per impostazione predefinita, il form di avvio viene denominato Form1.
Aggiungere il seguente campo testInstance alla classe Form1.
```
Dim WithEvents testInstance As TestInterface
```
Dichiarando testInstance come WithEvents, la classe Form1 può gestire i relativi eventi.

Aggiungere il seguente gestore eventi alla classe Form1 per gestire gli eventi generati da testInstance:

Sub EventHandler() Handles testInstance.Event1
    MsgBox("The event handler caught the event.")
End Sub

Aggiungere una subroutine denominata Test alla classe Form1 per testare l'implementazione della classe:

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 routine Test crea un'istanza della classe che implementa MyInterface, assegna l'istanza al campo testInstance, imposta una proprietà ed esegue un metodo mediante l'interfaccia.

Aggiungere codice per chiamare la routine Test dalla routine Form1 Load del form di avvio:

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

Premere F5 per eseguire la routine Test. Verrà visualizzato un messaggio che informa che Prop1 è stato impostato su 9. Scegliere OK. Verrà visualizzato un messaggio che informa che il parametro X per il metodo Method1 è 5. Scegliere nuovamente OK. Verrà visualizzato un messaggio che informa che l'evento è stato rilevato dal gestore eventi.