Procedura dettagliata: scrittura di un visualizzatore in C#

Articolo
02/19/2013

In questa procedura dettagliata viene descritto come utilizzare C# per scrivere un visualizzatore semplice,che consente di visualizzare il contenuto di una stringa in una finestra di messaggio di Windows Form.Questo semplice visualizzatore di stringhe non è particolarmente utile, ma consente di acquisire familiarità con le operazioni di base da effettuare per creare visualizzatori più utili per altri tipi di dati.

[!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 Impostazioni di Visual Studio.

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

Per creare un progetto Libreria di classi

Scegliere Nuovo dal menu File, quindi Nuovo progetto.
Nella finestra di dialogo Nuovo progetto selezionare Visual C# 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.Prima di aggiungere il riferimento, è tuttavia necessario rinominare alcune classi con nomi significativi.

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

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

[!NOTA]

In Visual Studio la dichiarazione di classe viene modificata automaticamente in base al nuovo nome di file DebuggerSide.cs.
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 Microsoft.VisualStudio.DebuggerVisualizers.DLL.
Scegliere OK.
In DebuggerSide.cs aggiungere la seguente istruzione alle istruzioni using:
```
using Microsoft.VisualStudio.DebuggerVisualizers;
```

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.cs posizionarsi sulla seguente riga di codice:
```
public class DebuggerSide
```

Modificare il codice in:

public class DebuggerSide : 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 seguente metodo:

override protected void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
{
}

Il metodo Show contiene il codice per la creazione della finestra di dialogo del visualizzatore o di 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 di Windows Form.È innanzitutto necessario aggiungere un riferimento e l'istruzione using 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.DLL.
Scegliere OK.
In DebuggerSide.cs aggiungere la seguente istruzione alle istruzioni using:
```
using System.Windows.Forms;
```

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.

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 dell'oggetto del debug

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

[assembly:System.Diagnostics.DebuggerVisualizer(
typeof(MyFirstVisualizer.DebuggerSide),
typeof(VisualizerObjectSource),
Target  = typeof(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.

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:

public static void TestShowVisualizer(object objectToVisualize)
{
   VisualizerDevelopmentHost visualizerHost = new VisualizerDevelopmentHost(objectToVisualize, typeof(DebuggerSide));
   visualizerHost.ShowVisualizer();
}

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 motivi di semplicità, verrà utilizzato un progetto di 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 scegliere 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.DLL.
Scegliere OK.
Fare clic con il pulsante destro del mouse su MyTestConsole e scegliere di nuovo Aggiungi riferimento.
Nella finestra di dialogo Aggiungi riferimento fare clic sulla scheda Progetti e quindi selezionare MyFirstVisualizer.
Scegliere OK.

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.cs e scegliere Rinomina dal menu di scelta rapida.
Sostituire Program.cs con un nome più significativo, ad esempio TestConsole.cs.

Nota In Visual Studio la dichiarazione di classe viene modificata automaticamente in base al nuovo nome di file TestConsole.cs.
In TestConsole.cs aggiungere il codice seguente alle istruzioni using:
```
using MyFirstVisualizer;
```

Nel metodo Main aggiungere il codice seguente:

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

A questo punto è possibile testare il 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.

L'applicazione console verrà avviata e 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.

Utilizzo del modello per la creazione di elementi visualizzatore

Fino a questo momento, in questa procedura dettagliata è stato descritto come creare un visualizzatore manualmentea scopo di esercitazione.Esiste tuttavia una procedura più facile per creare un visualizzatore, che consiste nell'utilizzare il modello per la creazione di elementi visualizzatore.

È innanzitutto necessario creare un nuovo progetto Libreria di classi.

Per creare una nuova libreria di classi

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

A questo punto è possibile aggiungere un elemento visualizzatore alla libreria.

Per aggiungere un elemento visualizzatore

In Esplora soluzioni fare clic con il pulsante destro del mouse su MySecondVisualizer.
Scegliere Aggiungi dal menu di scelta rapida, quindi Nuovo elemento.
Nella finestra di dialogo Aggiungi nuovo elemento scegliere Modelli Visual Studio installati in Modelli e selezionare Visualizzatore debugger.
Nella casella Nome immettere un nome appropriato, ad esempio SecondVisualizer.cs.
Scegliere Aggiungi.

La procedura per la creazione di un visualizzatore a partire da un modello è stata completata.Aprire il file SecondVisualizer.cs e controllare il codice aggiunto automaticamente dal modello.Provare a modificare il codice.Dopo avere appreso le nozioni di base, è possibile iniziare a creare visualizzatori personalizzati più utili e complessi.

Vedere anche

Condividi tramite