Procedura dettagliata: Scrittura di un visualizzatore in Visual Basic

2025-06-26

Importante

A partire da Visual Studio 2022 versione 17.9, i visualizzatori possono ora essere scritti in .NET 6.0+ per essere eseguiti out-of-process utilizzando il nuovo modello VisualStudio.Extensibility. Per le estensioni create con il nuovo modello, vedere invece la documentazione in Creare visualizzatori del debugger di Visual Studio . Se è necessario supportare le versioni precedenti di Visual Studio o si vogliono spedire i visualizzatori personalizzati come parte di una DLL di libreria, usare le informazioni contenute in questo articolo, che si applica solo al modello precedente di sviluppo di estensioni (VSSDK).

Questa procedura dettagliata illustra come scrivere un visualizzatore semplice usando Visual Basic. Il visualizzatore che verrà creato in questa procedura dettagliata visualizza il contenuto di una stringa usando una finestra di messaggio di Windows Form. Questo semplice visualizzatore di stringhe è un esempio di base per illustrare come è possibile creare visualizzatori per altri tipi di dati più applicabili ai progetti.

Annotazioni

Le finestre di dialogo e i comandi di menu visualizzati potrebbero essere diversi da quelli descritti nella Guida, a seconda delle impostazioni o dell'edizione attiva. Per modificare le impostazioni, passare al menu Strumenti e scegliere Importa ed Esporta . Per altre informazioni vedere Reimpostare le impostazioni.

Il codice del visualizzatore deve essere inserito in una DLL che verrà letta dal debugger. Il primo passaggio consiste nel creare un progetto di libreria di classi per la DLL.

Creare e preparare un progetto di libreria di classi

Per creare un progetto di libreria di classi

Creare un nuovo progetto di libreria di classi.

Premere esc per chiudere la finestra iniziale. Digitare CTRL+Q per aprire la casella di ricerca, digitare libreria di classi e quindi selezionare Visual Basic Class Library (.NET Framework).

Premere esc per chiudere la finestra iniziale. Digitare CTRL+Q per aprire la casella di ricerca, digitare visual basic, scegliere Modelli, quindi scegliere Crea una nuova libreria di classi (.NET Framework).
Digitare un nome appropriato per la libreria di classi, ad esempio MyFirstVisualizer, e quindi fare clic su Crea o OK.

Dopo aver creato la libreria di classi, è necessario aggiungere un riferimento a Microsoft.VisualStudio.DebuggerVisualizers.DLL, in modo da poter usare le classi definite. Prima di tutto, tuttavia, si assegna un nome significativo al progetto.

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.
Modificare il nome da Class1.vb a qualcosa di significativo, ad esempio DebuggerSide.vb.

Annotazioni

Visual Studio modifica automaticamente la dichiarazione di classe in DebuggerSide.vb in modo che corrisponda al nuovo nome file.
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 Sfoglia della finestra di dialogo Aggiungi riferimento selezionare Sfoglia e trovare il Microsoft.VisualStudio.DebuggerVisualizers.DLL.

È possibile trovare la DLL nel sottodirectory <Visual Studio Install Directory>\Common7\IDE\PublicAssemblies della directory di installazione di Visual Studio.
Fare clic su OK.
In DebuggerSide.vb aggiungere l'istruzione seguente alle Imports istruzioni :
```
Imports Microsoft.VisualStudio.DebuggerVisualizers
```

Aggiungere il codice sul lato debugger

Ora, puoi creare il codice per il lato debugger. Si tratta del codice eseguito all'interno del debugger per visualizzare le informazioni da visualizzare. Prima di tutto, è necessario modificare la dichiarazione dell'oggetto DebuggerSide in modo che erediti dalla classe DialogDebuggerVisualizerdi base .

Per ereditare da DialogDebuggerVisualizer

In DebuggerSide.vb passare alla riga di codice seguente:
```
Public Class DebuggerSide
```
Modificare il codice in modo che sia simile al seguente:
```
Public Class DebuggerSide
Inherits DialogDebuggerVisualizer
```
Annotazioni

DialogDebuggerVisualizer richiede un argomento FormatterPolicy nel suo costruttore. Tuttavia, a causa dei problemi di sicurezza descritti in Considerazioni speciali lato debugger per .NET 5.0+, a partire da Visual Studio 2022 versione 17.11, i visualizzatori non saranno in grado di specificare la politica del Legacy formattatore.

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

Per eseguire l'override del metodo DialogDebuggerVisualizer.Show

In public class DebuggerSideaggiungere il metodo seguente:
```
Protected Overrides Sub Show(ByVal windowService As Microsoft.VisualStudio.DebuggerVisualizers.IDialogVisualizerService, ByVal objectProvider As Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider)

    End Sub
```
Il Show metodo contiene il codice che crea effettivamente la finestra di dialogo del visualizzatore o un'altra interfaccia utente e visualizza le informazioni passate al visualizzatore dal debugger. È necessario aggiungere il codice che crea la finestra di dialogo e visualizzare le informazioni. In questa procedura dettagliata si userà una finestra di messaggio di Windows Form. Prima di tutto, devi aggiungere un riferimento e Imports un'istruzione per System.Windows.Forms.

Per aggiungere System.Windows.Forms

In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti e scegliere Aggiungi riferimento dal menu di scelta rapida.
Nella scheda Sfoglia della finestra di dialogo Aggiungi riferimento selezionare Sfoglia e trovare il System.Windows.Forms.DLL.

La DLL è disponibile in C:\Windows\Microsoft.NET\Framework\v4.0.30319.
Fare clic su OK.
In DebuggerSide.cs aggiungere l'istruzione seguente alle Imports istruzioni :
```
Imports System.Windows.Forms
```

Creare l'interfaccia utente del visualizzatore

A questo punto si aggiungerà del codice per creare e visualizzare l'interfaccia utente per il visualizzatore. Poiché si tratta del primo visualizzatore, si manterrà semplice l'interfaccia utente e si userà una finestra di messaggio.

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

Show Nel metodo aggiungere la riga di codice seguente:
```
MessageBox.Show(objectProvider.GetObject().ToString())
```
Questo codice di esempio non include la gestione degli errori. È consigliabile includere la gestione degli errori in un visualizzatore reale o in qualsiasi altro tipo di applicazione.
Scegliere Compila MyFirstVisualizer dal menu Compila. Il progetto dovrebbe essere completato con successo. Correggere eventuali errori di compilazione prima di continuare.

Aggiungere l'attributo necessario

Questa è la fine del codice sul lato del debugger. Esiste tuttavia un altro passaggio: l'attributo che indica al lato del debug quale raccolta di classi comprende il visualizzatore.

Per aggiungere il tipo da visualizzare per il codice lato debug

Nel codice sul lato del debugger, specificare il tipo da visualizzare (la sorgente dell'oggetto) per l'oggetto in debug utilizzando l'attributo DebuggerVisualizerAttribute. La Target proprietà imposta il tipo da visualizzare.

Aggiungere il codice di attributo seguente a DebuggerSide.vb, dopo le Imports istruzioni ma prima delle 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. Il progetto dovrebbe essere completato con successo. Correggere eventuali errori di compilazione prima di continuare.

Creare un test harness

A questo punto, il primo visualizzatore è terminato. Se sono stati eseguiti correttamente i passaggi, è possibile compilare il visualizzatore e installarlo in Visual Studio. Prima di installare un visualizzatore in Visual Studio, è tuttavia necessario testarlo per assicurarsi che venga eseguito correttamente. Si creerà ora 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. Il progetto dovrebbe essere completato con successo. Correggere eventuali errori di compilazione prima di continuare.

Successivamente, è necessario creare un progetto eseguibile per chiamare la DLL del visualizzatore. Per semplicità, usare un progetto di applicazione console.

Per aggiungere un progetto di applicazione console alla soluzione

In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione, scegliere Aggiungi e quindi fare clic su Nuovo progetto.

Nella casella Cerca digitare visual basic, scegliere Modelli, quindi scegliere Crea una nuova app console (.NET Framework). Nella finestra di dialogo visualizzata scegliere Crea.
Digitare un nome appropriato per la libreria di classi, ad esempio MyTestConsole, e quindi fare clic su Crea o OK.

È ora necessario aggiungere i riferimenti necessari in modo che MyTestConsole possa chiamare MyFirstVisualizer.

Per aggiungere i riferimenti necessari a MyTestConsole

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

Completare il test harness e testare il visualizzatore

A questo punto, si aggiungerà 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.
Modificare il nome da Module1.vb in un elemento appropriato, ad esempio TestConsole.vb.

Si noti che Visual Studio modifica automaticamente la dichiarazione di classe in TestConsole.vb in modo che corrisponda al nuovo nome file.
In TestConsole. vb: aggiungere l'istruzione seguente Imports
```
Imports MyFirstVisualizer
```
Nel metodo Mainaggiungere il codice seguente:
```
Dim myString As String = "Hello, World"
DebuggerSide.TestShowVisualizer(myString)
```
A questo momento si è pronti per testare il primo visualizzatore.

Per testare il visualizzatore

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

Viene avviata l'applicazione console. Il visualizzatore viene visualizzato e visualizza la stringa "Hello, World".

Felicitazioni. Il primo visualizzatore è stato appena compilato e testato.

Se si vuole usare il visualizzatore in Visual Studio anziché semplicemente chiamarlo dal test harness, è necessario installarlo. Per altre informazioni, vedere Procedura: Installare un visualizzatore.

Condividi tramite