Procedura dettagliata: scrittura di un visualizzatore in C#

In questa procedura dettagliata viene descritto come usare C# per creare un visualizzatore semplice Il visualizzatore creato in questa procedura dettagliata visualizza il contenuto di una stringa usando un Windows Form. Questo visualizzatore di stringhe semplice non è particolarmente utile in se stesso, ma mostra i passaggi di base da seguire per creare visualizzatori più utili per altri tipi di dati.

Il codice del visualizzatore deve essere inserito in un file DLL letto dal debugger. Di conseguenza, il primo passaggio consiste nel creare un progetto libreria di classi per la DLL.

Creare manualmente un visualizzatore

Completare le attività seguenti per creare un visualizzatore.

Creare un progetto di libreria di classi

1. Per creare un nuovo progetto di libreria di classi, selezionare File>Nuovo>progetto.

2. Nell'elenco a discesa del linguaggio selezionare C#.

3. Nella casella di ricerca immettere libreria di classi. Selezionare Libreria di classi (.NET Framework) e quindi Avanti.

4. Nella finestra di dialogo immettere il nome MyFirstVisualizere quindi selezionare Crea.

Per il progetto del visualizzatore, assicurarsi di selezionare una libreria di classi .NET Framework e non .NET. Anche se il visualizzatore deve essere .NET Framework, l'app chiamante può essere .NET.

Dopo aver creato la libreria di classi, è necessario aggiungere un riferimento al Microsoft.VisualStudio.DebuggerVisualizers.DLL file in modo da poter usare le classi definite. Prima di aggiungere il riferimento, è necessario rinominare alcune classi per usare nomi significativi.

Rinominare Class1.cs e aggiungere Microsoft.VisualStudio.DebuggerVisualizers

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

2. Modificare il nome da Class1.cs a qualcosa di significativo, ad esempio DebuggerSide.cs.

   Nota

   Visual Studio modifica automaticamente la dichiarazione di classe in DebuggerSide.cs in modo che corrisponda al nuovo nome file. Se viene visualizzato un prompt per completare l'azione, selezionare Sì.

3. In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti 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. Seleziona OK.

6. In DebuggerSide.cs aggiungere quanto segue alle using direttive :

   using Microsoft.VisualStudio.DebuggerVisualizers;
   

A questo momento è possibile creare il codice sul lato debugger. Questo codice viene eseguito all'interno del debugger per visualizzare le informazioni da visualizzare. Prima di tutto, è necessario modificare la dichiarazione dell'oggetto per configurare l'ereditarietà DebuggerSide dalla classe DialogDebuggerVisualizerbase .

Ereditare da DialogDebuggerVisualizer

1. In DebuggerSide.cs passare alla riga di codice seguente:

   public class DebuggerSide
   

2. Modificare il codice in:

   public class DebuggerSide : DialogDebuggerVisualizer
   

3. Aggiungere un costruttore vuoto in modo da poter passare al costruttore della classe base i criteri di serializzazione che verranno usati per comunicare tra i componenti del visualizzatore.

   public DebuggerSide() : base(FormatterPolicy.NewtonsoftJson) // or FormatterPolicy.Json
   {
   }
   

   Nota

   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 potranno specificare i criteri del Legacy formattatore.

4. DialogDebuggerVisualizer ha un solo metodo astratto, Show, di cui è necessario eseguire l'override.

Eseguire l'override del metodo DialogDebuggerVisualizer.Show

In public class DebuggerSide aggiungere il seguente metodo:

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

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. In questa procedura dettagliata si usa una finestra di messaggio Windows Form. Prima di tutto, è necessario aggiungere un riferimento e using una direttiva per System.Windows.Forms.

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. Seleziona OK.

4. In DebuggerSide.cs aggiungere quanto segue alle using direttive :

   using System.Windows.Forms;
   

Ora si aggiunge codice per creare e visualizzare l'interfaccia utente per il visualizzatore. Poiché questo esempio è il primo visualizzatore, è possibile mantenere semplice l'interfaccia utente e usare una finestra di messaggio.

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. È consigliabile includere la gestione degli errori in un visualizzatore reale o in qualsiasi altro tipo di applicazione.

2. 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 laterale del debugger è ora completo. C'è un altro passo, tuttavia; attributo che indica al lato del debug quale raccolta di classi comprende il visualizzatore.

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.cs, dopo le using direttive ma prima namespace MyFirstVisualizerdi :

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

   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. È ora possibile creare un test harness per eseguire il visualizzatore senza installarlo in Visual Studio.

Aggiungere un metodo di test per visualizzare il visualizzatore

1. Aggiungere il metodo seguente alla classe public DebuggerSide:

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

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à, usare un progetto applicazione console.

Aggiungere un progetto di applicazione console alla soluzione

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

2. Scegliere File>Nuovo>Progetto. Nell'elenco a discesa del linguaggio scegliere C#. Nella casella di ricerca digitare app console e quindi scegliere App console (.NET Framework) o Applicazione console per .NET. Selezionare Avanti. Nella finestra di dialogo visualizzata digitare il nome MyTestConsolee quindi selezionare Crea.

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

Aggiungere i riferimenti necessari a MyTestConsole

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

2. Nella finestra di dialogo Aggiungi riferimento aprire la scheda Sfoglia e selezionare Microsoft.VisualStudio.DebuggerVisualizers.DLL.

3. Seleziona OK.

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

5. Nella finestra di dialogo Aggiungi riferimento aprire la scheda Progetti e selezionare MyFirstVisualizer.

6. Seleziona OK.

Aggiungere ora il codice per completare il test harness.

Aggiungere codice a MyTestConsole

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

2. Modificare il nome da Program.cs a qualcosa di più significativo, ad esempio TestConsole.cs.

   Nota

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

3. In TestConsole.cs aggiungere il codice seguente alle using direttive :

   using MyFirstVisualizer;
   

4. Nel metodo Main aggiungere il codice seguente:

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

A questo momento, si è pronti per testare il primo visualizzatore.

Testare il 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.

   L'applicazione console viene avviata e il visualizzatore viene visualizzata e viene visualizzata la stringa "Hello, World".

Congratulazioni. Il primo visualizzatore è stato creato 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.

Aggiungere un oggetto dati sul lato debug

In questa sezione si passa dall'oggetto System.String dati a un oggetto dati personalizzato.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione, scegliere Aggiungi e quindi selezionare Nuovo progetto. Nell'elenco a discesa del linguaggio scegliere C#. Nella casella di ricerca digitare libreria di classi e quindi scegliere Libreria di classi (.NET Framework) o Libreria di classi per .NET Standard.

   Nota

   Se si usa un'app console di test di .NET Framework, assicurarsi di creare un progetto di libreria di classi .NET Framework.

2. Selezionare Avanti. Nella finestra di dialogo visualizzata digitare il nome MyDataObjecte quindi selezionare Crea.

3. (solo libreria di classi.NET Standard) In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto. Modificare il <TargetFramework> valore in netstandard2.0.

   <TargetFramework>netstandard2.0</TargetFramework>
   

4. All'interno dello spazio dei MyDataObject nomi sostituire il codice predefinito con il codice seguente.

   [Serializable] 
   public class CustomDataObject
   {
      public CustomDataObject()
      {
         this.MyData = "MyTestData";
      }
      public string MyData { get; set; }
   }
   

   Per un visualizzatore di sola lettura, ad esempio in questo esempio, non è necessario implementare metodi di VisualizerObjectSource.

   Aggiornare quindi il progetto MyFirstVisualizer per usare il nuovo oggetto dati.

5. In Esplora soluzioni sotto il progetto MyFirstVisualizer fare clic con il pulsante destro del mouse sul nodo Riferimenti e scegliere Aggiungi riferimento.

6. In Progetti selezionare il progetto MyDataObject .

7. Nel codice dell'attributo di DebuggerSide.cs aggiornare il valore target, impostando System.String su MyDataObject.CustomDataObject.

   Target = typeof(MyDataObject.CustomDataObject),
   

8. Nel progetto MyFirstVisualizer sostituire il codice per il Show metodo con il codice seguente.

   var data = objectProvider.GetObject() as MyDataObject.CustomDataObject;
   
   // You can replace displayForm with your own custom Form or Control.  
   Form displayForm = new Form();
   displayForm.Text = data.MyData;
   windowService.ShowDialog(displayForm);
   

   Il codice precedente usa una proprietà dell'oggetto dati da visualizzare nel titolo del modulo.

   Aggiornare quindi l'app console per usare l'oggetto dati personalizzato.

9. In Esplora soluzioni sotto il progetto MyTestConsole fare clic con il pulsante destro del mouse sul nodo Riferimenti o dipendenze e aggiungere un riferimento al progetto a MyDataObject.

10. In Program.cs sostituire il codice nel Main metodo con il codice seguente.

    // String myString = "Hello, World";
    CustomDataObject customDataObject = new CustomDataObject();
    
    DebuggerSide.TestShowVisualizer(customDataObject);
    

11. (app console.NET) Racchiudere la chiamata a TestShowVisualizer in un'istruzione try-catch, perché il test harness non è supportato.

    try
    {
          DebuggerSide.TestShowVisualizer(customDataObject);
    }
    catch (Exception) {
    }
    

    L'app console richiede un riferimento di runtime al visualizzatore. È possibile mantenere il riferimento mantenendo il codice precedente anziché impostarlo come commento.

12. Per un'app console .NET Framework, è possibile eseguire il test harness (premere F5) oppure seguire le istruzioni in Procedura: Installare un visualizzatore.

    Se si esegue l'app usando il test harness, l'app visualizza Windows Form.

13. Per un'app console .NET, copiare MyFirstVisualizer.dll e nelle MyDataObject.dll cartelle descritte in Procedura: Installare un visualizzatore.

14. Dopo aver installato il visualizzatore, impostare un punto di interruzione, eseguire l'app console e passare il puntatore del mouse su customDataObject. Se tutto è configurato correttamente, verrà visualizzata l'icona della lente di ingrandimento .

    

    Quando si sceglie MyFirstVisualizer dalla lente di ingrandimento, il form viene visualizzato con il testo dell'oggetto dati nel titolo.

    

Contenuto correlato

• Architettura del visualizzatore
• Procedura: Installare un visualizzatore
• Creare visualizzatori personalizzati