Procedura dettagliata: scrittura di un visualizzatore in Visual Basic

Articolo
06/10/2015

In questa procedura dettagliata viene descritto come utilizzare Visual Basic per scrivere un visualizzatore semplice che consente di visualizzare il contenuto di una stringa in una finestra di messaggio di Windows Form. Questo visualizzatore semplice di stringhe è un esempio base per illustrare la creazione di visualizzatori per altri tipi di dati più applicabili ai progetti.

Nota

Le finestre di dialogo e i comandi di menu visualizzati potrebbero non corrispondere a quelli descritti nella Guida in quanto dipendono dall'edizione o dalle impostazioni in uso.Per modificare le impostazioni, scegliere Importa/Esporta impostazioni dal menu Strumenti.Per ulteriori informazioni, vedere Personalizzazione delle impostazioni di sviluppo in Visual Studio.

Il codice del visualizzatore deve essere inserito in una DLL, che verrà letta dal debugger. La prima operazione da effettuare consiste nel creare un progetto Libreria di classi per la DLL.

Creare e preparare un progetto Libreria di classi

Per creare un progetto Libreria di classi

Scegliere Nuovo dal menu File, quindi Nuovo progetto.
Nella finestra di dialogo Nuovo progetto selezionare Visual Basic in Tipo progetto.
Nella casella Modelli scegliere Libreria di classi.
Nella casella Nome digitare un nome appropriato per la libreria di classi, ad esempio MyFirstVisualizer.
Scegliere OK.

Dopo avere creato la libreria di classi, è necessario aggiungere un riferimento a Microsoft.VisualStudio.DebuggerVisualizers.DLL in modo da poter utilizzare le classi definite in questa DLL. Innanzitutto è opportuno assegnare al progetto un nome significativo.

Per rinominare Class1.vb e aggiungere Microsoft.VisualStudio.DebuggerVisualizers

In Esplora soluzioni fare clic con il pulsante destro del mouse su Class1.vb e scegliere Rinomina dal menu di scelta rapida.
Sostituire Class1.vb con un nome significativo, ad esempio DebuggerSide.vb.

Nota

In Visual Studio la dichiarazione di classe viene modificata automaticamente in base al nuovo nome di file DebuggerSide.vb.
In Esplora soluzioni, fare clic con il pulsante destro del mouse su My First Visualizer e scegliere Aggiungi riferimento dal menu di scelta rapida.
Nella scheda .NET della finestra di dialogo Aggiungi riferimento scegliere Microsoft.VisualStudio.DebuggerVisualizers.DLL.
Scegliere OK.
In DebuggerSide.vb aggiungere l'istruzione seguente alle istruzioni Imports:
```
Imports Microsoft.VisualStudio.DebuggerVisualizers
```

Aggiungere il codice sul lato debugger

A questo punto è possibile creare il codice sul lato debugger. Questo codice verrà eseguito all'interno del debugger per visualizzare le informazioni desiderate. È innanzitutto necessario modificare la dichiarazione dell'oggetto DebuggerSide in modo da ereditare dalla classe di base DialogDebuggerVisualizer.

Per ereditare da DialogDebuggerVisualizer

In DebuggerSide.vb posizionarsi sulla riga di codice seguente:
```
Public Class DebuggerSide
```

Modificare il codice nel modo seguente:

Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

DialogDebuggerVisualizer dispone di un metodo astratto, Show, di cui è necessario eseguire l'override.

Per eseguire l'override del metodo DialogDebuggerVisualizer.Show

In public class DebuggerSide aggiungere il metodo seguente:

Protected Overrides Sub Show(ByVal windowService As Microsoft.VisualStudio.DebuggerVisualizers.IDialogVisualizerService, ByVal objectProvider As Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider)

    End Sub

Il metodo Show contiene il codice per la creazione della finestra di dialogo del visualizzatore o un'altra interfaccia utente e per la visualizzazione delle informazioni passate al visualizzatore dal debugger. Questo codice deve essere aggiunto dallo sviluppatore. A tale scopo, in questa procedura dettagliata verrà utilizzata una finestra di messaggio Windows Form. È innanzitutto necessario aggiungere un riferimento e l'istruzione Imports per System.Windows.Forms.

Per aggiungere System.Windows.Forms

In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti, quindi scegliere Aggiungi riferimento dal menu di scelta rapida.
Nella scheda .NET della finestra di dialogo Aggiungi riferimento scegliere System.Windows.Forms.
Scegliere OK.
In DebuggerSide.cs aggiungere l'istruzione seguente alle istruzioni Imports:
```
Imports System.Windows.Forms
```

Creare un'interfaccia utente del visualizzatore

A questo punto è necessario aggiungere una sezione di codice per la creazione e la visualizzazione dell'interfaccia utente del visualizzatore. Poiché si tratta del primo visualizzatore creato, l'interfaccia utente sarà semplice e verrà utilizzata una finestra di messaggio.

Per visualizzare l'output del visualizzatore in una finestra di dialogo

Nel metodo Show aggiungere la riga di codice seguente:
```
MessageBox.Show(objectProvider.GetObject().ToString())
```
Questo codice di esempio non include la gestione degli errori. In un vero visualizzatore o in un qualsiasi altro tipo di applicazione è consigliabile includere la gestione degli errori.
Scegliere Compila MyFirstVisualizer dal menu Compila. La compilazione del progetto dovrebbe avvenire senza problemi. Correggere gli eventuali errori di compilazione prima di continuare.

Aggiungere l'attributo necessario

Il codice sul lato debugger è stato completato. È tuttavia necessario eseguire un altro passaggio, ovvero specificare l'attributo che indica al lato dell'oggetto del debug la raccolta di classi che comprende il visualizzatore.

Per aggiungere il codice del lato oggetto del debug

Aggiungere il codice di attributo seguente a DebuggerSide.vb, dopo le istruzioni Imports ma prima di namespace MyFirstVisualizer:

<Assembly: System.Diagnostics.DebuggerVisualizer(GetType(MyFirstVisualizer.DebuggerSide), GetType(VisualizerObjectSource), Target:=GetType(System.String), Description:="My First Visualizer")>

Scegliere Compila MyFirstVisualizer dal menu Compila. La compilazione del progetto dovrebbe avvenire senza problemi. Correggere gli eventuali errori di compilazione prima di continuare.

Creare un test harness

A questo punto il visualizzatore è pronto. Se la procedura è stata completata in modo corretto, è possibile compilare il visualizzatore e installarlo in Visual Studio. Prima di installare un visualizzatore in Visual Studio, è tuttavia consigliabile testarlo per assicurarsi che funzioni in modo corretto. Di seguito viene descritto come creare un test harness per eseguire il visualizzatore senza installarlo in Visual Studio.

Per aggiungere un metodo di test per visualizzare il visualizzatore

Aggiungere il metodo seguente alla classe public DebuggerSide:

Shared Public Sub TestShowVisualizer(ByVal objectToVisualize As Object)
    Dim visualizerHost As New VisualizerDevelopmentHost(objectToVisualize, GetType(DebuggerSide))
visualizerHost.ShowVisualizer()
End Sub

Scegliere Compila MyFirstVisualizer dal menu Compila. La compilazione del progetto dovrebbe avvenire senza problemi. Correggere gli eventuali errori di compilazione prima di continuare.

Creare quindi un progetto eseguibile per chiamare la DLL del visualizzatore. Per semplicità, utilizzare un progetto applicazione console.

Per aggiungere un progetto applicazione console alla soluzione

Scegliere Aggiungi dal menu File, quindi Nuovo progetto.
Nel riquadro Modelli della finestra di dialogo Aggiungi nuovo progetto fare clic su Applicazione console.
Nella casella Nome, digitare un nome significativo per l'applicazione console, ad esempio MyTestConsole.
Scegliere OK.

A questo punto è necessario aggiungere i riferimenti appropriati affinché MyTestConsole possa chiamare MyFirstVisualizer.

Per aggiungere riferimenti necessari a MyTestConsole

In Esplora soluzioni fare clic con il pulsante destro del mouse su MyTestConsole, quindi scegliere Aggiungi riferimento dal menu di scelta rapida.
Nella scheda .NET della finestra di dialogo Aggiungi riferimento scegliere Microsoft.VisualStudio.DebuggerVisualizers.
Scegliere OK.
Fare clic con il pulsante destro del mouse su MyTestConsole e scegliere nuovamente Aggiungi riferimento.
Nella finestra di dialogo Aggiungi riferimento fare clic sulla scheda Progetti e selezionare MyFirstVisualizer.
Scegliere OK.

Completare il test harness ed eseguire il test del visualizzatore

A questo punto verrà aggiunto il codice per completare il test harness.

Per aggiungere codice a MyTestConsole

In Esplora soluzioni fare clic con il pulsante destro del mouse su Program.vb e scegliere Rinomina dal menu di scelta rapida.
Sostituire Module1.vb con un nome appropriato, ad esempio TestConsole.vb.

Si noti che in Visual Studio la dichiarazione di classe viene modificata automaticamente in TestConsole.vb in base al nuovo nome file.
In TestConsole.vb aggiungere l'istruzione Imports seguente:
```
Imports MyFirstVisualizer
```

Nel metodo Main aggiungere il codice seguente:

Dim myString As String = "Hello, World"
DebuggerSide.TestShowVisualizer(myString)

A questo punto è possibile eseguire il test del visualizzatore.

Per eseguire il test del visualizzatore

In Esplora soluzioni fare clic con il pulsante destro del mouse su MyTestConsole, quindi scegliere Imposta come progetto di avvio dal menu di scelta rapida.
Scegliere Avvia dal menu Debug.

Verrà avviata l'applicazione console. Verrà aperto il visualizzatore contenente la stringa "Hello, World".

Il visualizzatore è stato compilato e sottoposto a test.

Se si desidera utilizzare il visualizzatore in Visual Studio anziché chiamarlo semplicemente dal test harness, è necessario installarlo. Per ulteriori informazioni, vedere Procedura: installare un visualizzatore.

Vedere anche

Condividi tramite