Share via

Procedura dettagliata: scrittura di un visualizzatore in Visual Basic

  • Articolo

Importante

A partire da Visual Studio 2022 versione 17.9, i visualizzatori possono ora essere scritti in .NET 6.0+ che eseguono out-of-process usando il nuovo modello VisualStudio.Extensibility. Si consiglia agli autori del visualizzatore di fare riferimento alla nuova documentazione in Creare visualizzatori del debugger di Visual Studio, a meno che non vogliano supportare le versioni precedenti di Visual Studio o che vogliano spedire i visualizzatori personalizzati come parte di una DLL di libreria.

Questa procedura dettagliata illustra come scrivere un visualizzatore semplice usando Visual Basic. 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, passare al menu Strumenti e scegliere Importa/Esporta. Per altre informazioni vedere Reimpostare le impostazioni.

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

  1. Creare un nuovo progetto Libreria di classi.

    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). Nella finestra di dialogo visualizzata scegliere Crea.

  2. Digitare un nome appropriato per la libreria di classi, ad esempio MyFirstVisualizer, e quindi fare clic su Crea o 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

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su Class1.vb e scegliere Rinomina dal menu di scelta rapida.

  2. Sostituire Class1.vb con un nome significativo, ad esempio DebuggerSide.vb.

    Nota

    Visual Studio modifica automaticamente la dichiarazione di classe in DebuggerSide.vb in modo che corrisponda al nuovo nome file.

  3. In Esplora soluzioni fare clic son il pulsante destro del mouse su My First Visualizer e scegliere Aggiungi riferimento dal menu di scelta rapida.

  4. Nella scheda Sfoglia della finestra di dialogo Aggiungi riferimento selezionare Sfoglia e trovare il Microsoft.VisualStudio.DebuggerVisualizers.DLL.

    È possibile trovare la DLL nella <directory di installazione di Visual Studio>\Common7\IDE\PublicAssemblies della directory di installazione di Visual Studio.

  5. Fare clic su OK.

  6. 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

  1. In DebuggerSide.vb posizionarsi sulla riga di codice seguente:

    Public Class DebuggerSide

  2. Modificare il codice nel modo seguente:

    Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

    Nota

    DialogDebuggerVisualizer prevede un FormatterPolicy argomento nel relativo costruttore. Tuttavia, a causa dei problemi di sicurezza descritti in Considerazioni sul lato debugger speciali per .NET 5.0+, a partire da Visual Studio 2022 versione 17.11, i visualizzatori non saranno in grado di specificare i criteri 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 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

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti e scegliere Aggiungi riferimento dal menu di scelta rapida.

  2. 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.

  3. Fare clic su OK.

  4. 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

  1. 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.

  2. 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 tipo da visualizzare per il codice lato debug

Nel codice sul lato debugger si specifica il tipo da visualizzare (l'origine oggetto) per l'oggetto di debug usando l'attributo DebuggerVisualizerAttribute . La Target proprietà imposta il tipo da visualizzare.

  1. 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")>

  2. 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 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. Verrà ora creato un test harness per eseguire il visualizzatore senza installarlo in Visual Studio.

Per aggiungere un metodo di test per visualizzare il visualizzatore

  1. 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

  2. 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

  1. 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.

  2. Digitare un nome appropriato per la libreria di classi, ad esempio MyTestConsole, e quindi fare clic su Crea o OK.

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

Per aggiungere riferimenti necessari a MyTestConsole

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su MyTestConsole, quindi scegliere Aggiungi riferimento dal menu di scelta rapida.

  2. Nella scheda Sfoglia della finestra di dialogo Aggiungi riferimento fare clic su Microsoft.VisualStudio.DebuggerVisualizers.

  3. Fare clic su OK.

  4. Fare clic con il pulsante destro del mouse su MyTestConsole e scegliere nuovamente Aggiungi riferimento.

  5. Nella finestra di dialogo Aggiungi riferimento fare clic sulla scheda Progetti e selezionare MyFirstVisualizer.

  6. Fare clic su 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

  1. In Esplora soluzioni fare clic con il pulsante destro del mouse su Program.vb e scegliere Rinomina dal menu di scelta rapida.

  2. Sostituire Module1.vb con un nome 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.

  3. In TestConsole. vb, aggiungere l'istruzione seguente Imports :

    Imports MyFirstVisualizer

  4. 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

  1. 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.

  2. Scegliere Avvia dal menu Debug.

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

    Congratulazioni. è stato compilato e sottoposto a test.

    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.

Contenuto correlato