Walkthrough: Een visualizer schrijven in C#

Belangrijk

Vanaf Visual Studio 2022 versie 17.9 kunnen visualizers nu worden geschreven in .NET 6.0+, die buiten het proces worden uitgevoerd met behulp van het nieuwe VisualStudio.Extensibility-model. Zie de documentatie bij Visual Studio-foutopsporingsprogramma's maken voor extensies die zijn gemaakt met behulp van het nieuwe model. Als u oudere versies van Visual Studio wilt ondersteunen of uw aangepaste visuals wilt verzenden als onderdeel van een bibliotheek-DLL, gebruikt u de informatie in dit artikel, die alleen van toepassing is op het oudere model voor uitbreidingsontwikkeling (VSSDK).

In deze rondleiding ziet u hoe u een eenvoudige visualisator kunt schrijven met behulp van C#. De visualisatie die u in deze handleiding maakt, geeft de inhoud van een tekenreeks weer via een Windows-formulier. Deze eenvoudige tekenreeksvisualisator is op zichzelf niet bijzonder nuttig, maar het toont de basisstappen die u moet volgen om nuttigere visualisatoren te maken voor andere gegevenssoorten.

Opmerking

De dialoogvensters en menuopdrachten die u ziet, kunnen afwijken van de dialoogvensters en menuopdrachten die worden beschreven in Help, afhankelijk van uw actieve instellingen of editie. Als u uw instellingen wilt wijzigen, gaat u naar het menu Extra en kiest u Instellingen importeren en exporteren. Zie Instellingen opnieuw instellen voor meer informatie.

Visualr-code moet worden geplaatst in een DLL-bestand dat het foutopsporingsprogramma leest. Daarom is de eerste stap het maken van een klassebibliotheekproject voor het DLL-bestand.

Handmatig een visualizer maken

Voer de volgende taken uit om een visualisatie te maken.

Een klassebibliotheekproject maken

Als u een nieuw klassebibliotheekproject wilt maken, selecteert u Bestand>nieuw>project.
Selecteer C# in de vervolgkeuzelijst taal.
Voer class library in het zoekvak in. Selecteer Klassebibliotheek (.NET Framework) en klik op Volgende.
Voer in het dialoogvenster de naam MyFirstVisualizer in en selecteer maken.

Zorg ervoor dat u voor het visualrproject een .NET Framework-klassebibliotheek en niet .NET selecteert. Hoewel de visualizer .NET Framework moet zijn, kan de aanroepende app .NET zijn.

Nadat u de klassebibliotheek hebt gemaakt, moet u een verwijzing naar het Microsoft.VisualStudio.DebuggerVisualizers.DLL bestand toevoegen, zodat u de klassen kunt gebruiken die daar zijn gedefinieerd. Voordat u de verwijzing toevoegt, moet u de naam van sommige klassen wijzigen om betekenisvolle namen te gebruiken.

Naam van Class1.cs wijzigen en Microsoft.VisualStudio.DebuggerVisualizers toevoegen

Klik in Solution Explorer met de rechtermuisknop op Class1.cs en selecteer Naam wijzigen in het contextmenu.
Wijzig de naam van Class1.cs in iets zinvols, zoals DebuggerSide.cs.

Opmerking

Visual Studio wijzigt automatisch de klassedeclaratie in DebuggerSide.cs zodat deze overeenkomt met de nieuwe bestandsnaam. Als u een prompt ziet om de actie te voltooien, selecteert u Ja.
Klik in Solution Explorer met de rechtermuisknop op Verwijzingen en kies Verwijzing toevoegen in het snelmenu.
In het dialoogvenster Verwijzing toevoegen, ga naar het tabblad Bladeren, selecteer Bladeren en zoek de Microsoft.VisualStudio.DebuggerVisualizers.DLL.

U vindt het DLL-bestand in <Visual Studio Install Directory>\Common7\IDE\PublicAssemblies submap van de installatiemap van Visual Studio.
Kies OK.
Voeg in DebuggerSide.cs het volgende toe aan de using instructies:
```
using Microsoft.VisualStudio.DebuggerVisualizers;
```

U kunt nu de debugger-kantcode maken. Deze code wordt uitgevoerd in het foutopsporingsprogramma om de informatie weer te geven die u wilt visualiseren. Eerst moet u de declaratie van het DebuggerSide object wijzigen om overname van de basisklasse DialogDebuggerVisualizerte configureren.

Overnemen van DialogDebuggerVisualizer

Ga in DebuggerSide.cs naar de volgende regel van code:
```
public class DebuggerSide
```

Wijzig de code in:

public class DebuggerSide : DialogDebuggerVisualizer

Voeg een lege constructor toe, zodat u het serialisatiebeleid kunt doorgeven aan de constructor van de basisklasse, dat wordt gebruikt om te communiceren tussen de onderdelen van de visualizer.
```
public DebuggerSide() : base(FormatterPolicy.NewtonsoftJson) // or FormatterPolicy.Json
{
}
```
Opmerking

Vanwege de beveiligingsproblemen die worden beschreven in Speciale overwegingen voor debugger-programma's bij .NET 5.0+, kunnen visualisators vanaf Visual Studio 2022 versie 17.11 het Legacy formatteringsbeleid niet opgeven.
DialogDebuggerVisualizer heeft één abstracte methode (Show) die u moet overschrijven.

De methode DialogDebuggerVisualizer.Show overschrijven

Voeg public class DebuggerSidede volgende methode toe :

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

De Show methode bevat de code waarmee het dialoogvenster visualizer of andere gebruikersinterface daadwerkelijk wordt gemaakt en de informatie wordt weergegeven die vanuit het foutopsporingsprogramma is doorgegeven aan de visualizer. U moet de code toevoegen waarmee het dialoogvenster wordt gemaakt en de informatie wordt weergegeven. Tijdens deze handleiding gebruikt u een Windows Forms-berichtvak. Eerst moet u een verwijzing en using instructie toevoegen voor System.Windows.Forms.

System.Windows.Forms toevoegen

Klik in Solution Explorer met de rechtermuisknop op Verwijzingen en kies Verwijzing toevoegen in het snelmenu.
In het dialoogvenster Verwijzing toevoegen, op het tabblad Bladeren, selecteer Bladeren en zoek de System.Windows.Forms.DLL.

U vindt het DLL-bestand in C:\Windows\Microsoft.NET\Framework\v4.0.30319.
Kies OK.
Voeg in DebuggerSide.cs het volgende toe aan de using instructies:
```
using System.Windows.Forms;
```

Nu voegt u code toe om de gebruikersinterface voor uw visualisator te maken en weer te geven. Omdat dit voorbeeld uw eerste visualisatie is, kunt u de gebruikersinterface eenvoudig houden en een berichtenvak gebruiken.

De uitvoer van Visualizer weergeven in een dialoogvenster

Voeg in de Show methode de volgende coderegel toe:
```
MessageBox.Show(objectProvider.GetObject().ToString());
```
Deze voorbeeldcode bevat geen foutafhandeling. U moet foutafhandeling opnemen in een echte visualisatie of een ander type toepassing.
Kies Build MyFirstVisualizer in het menu Build. Het project moet succesvol worden gebouwd. Corrigeer eventuele buildfouten voordat u doorgaat.

Nu is de code aan de kant van het foutopsporingsprogramma voltooid. , Er is echter nog een stap: Het kenmerk dat aan de foutopsporingszijde aangeeft welke verzameling klassen de visualizer bevat.

Voeg het type toe dat moet worden gevisualiseerd voor de code aan de kant van de foutopsporing

In de debuggercode geeft u het type op dat moet worden gevisualiseerd (de objectbron) voor de debuggee met behulp van het DebuggerVisualizerAttribute attribuut. Met de Target eigenschap wordt het type ingesteld dat moet worden gevisualiseerd.

Voeg de volgende kenmerkcode toe aan DebuggerSide.cs, na de using instructies maar vóór namespace MyFirstVisualizer:

[assembly:System.Diagnostics.DebuggerVisualizer(
typeof(MyFirstVisualizer.DebuggerSide),
typeof(VisualizerObjectSource),
Target = typeof(System.String),
Description = "My First Visualizer")]

Kies Build MyFirstVisualizer in het menu Build. Het project moet succesvol worden gebouwd. Corrigeer eventuele buildfouten voordat u doorgaat.

Op dit moment is uw eerste visualisatie voltooid. Als u de stappen correct hebt gevolgd, kunt u de visualizer bouwen en installeren in Visual Studio. Voordat u een visualizer in Visual Studio installeert, moet u deze echter testen om ervoor te zorgen dat deze correct wordt uitgevoerd. U maakt nu een testharnas om de visualizer uit te voeren zonder deze in Visual Studio te installeren.

Een testmethode toevoegen om de visualisatie weer te geven

Voeg de volgende methode toe aan klasse public DebuggerSide:

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

Kies Build MyFirstVisualizer in het menu Build. Het project moet succesvol worden gebouwd. Corrigeer eventuele buildfouten voordat u doorgaat.

Vervolgens moet u een uitvoerbaar project maken om uw visualizer-DLL aan te roepen. Gebruik voor het gemak een consoletoepassingsproject.

Een consoletoepassingsproject toevoegen aan de oplossing

Klik in Solution Explorer met de rechtermuisknop op de oplossing, kies Toevoegen en selecteer vervolgens Nieuw project.
Kies Bestand>Nieuw>Project. Kies C# in de vervolgkeuzelijst taal. Typ de console-app in het zoekvak en kies console-app (.NET Framework) of consoletoepassing voor .NET. Kies Volgende. Typ in het dialoogvenster dat wordt weergegeven de naam MyTestConsole, en selecteer vervolgens Maken.

Opmerking

Als u de visual eenvoudig wilt testen met behulp van een testharnas, maakt u een .NET Framework-console-app. U kunt in plaats daarvan een .NET-console-app maken, maar de testharnas die later wordt beschreven, wordt nog niet ondersteund voor .NET, dus moet u de visualizer installeren om deze te testen. Voor een .NET-console-app maakt u eerst de console-app hier, voegt u de vereiste DLL- en projectverwijzingen toe en volgt u vervolgens de stappen die worden beschreven in Een gegevensobject aan de foutopsporingszijde toevoegen. Zie Speciale overwegingen voor foutopsporingsprogramma's voor .NET 5.0+ voor ASP.NET Core-scenario's.

Nu moet u de benodigde verwijzingen toevoegen, zodat MyTestConsole MyFirstVisualizer kan aanroepen.

Voeg de benodigde verwijzingen toe aan MyTestConsole

Klik in Solution Explorer met de rechtermuisknop op MyTestConsole en kies Verwijzing toevoegen in het snelmenu.
Open in het dialoogvenster Verwijzing toevoegen het tabblad Bladeren en selecteer Microsoft.VisualStudio.DebuggerVisualizers.DLL.
Kies OK.
Klik met de rechtermuisknop op MyTestConsole en kies Opnieuw verwijzing toevoegen .
Open in het dialoogvenster Verwijzing toevoegen het tabblad Projecten en selecteer MyFirstVisualizer.
Kies OK.

Nu voegt u de code toe om het testharnas te voltooien.

Code toevoegen aan MyTestConsole

Klik in Solution Explorer met de rechtermuisknop op Program.cs en kies Naam wijzigen in het snelmenu.
Bewerk de naam van Program.cs naar iets zinvoller, zoals TestConsole.cs.

Opmerking

Visual Studio wijzigt automatisch de klassedeclaratie in TestConsole.cs zodat deze overeenkomt met de nieuwe bestandsnaam.
Voeg in TestConsole.cs de volgende code toe aan de using instructies:
```
using MyFirstVisualizer;
```

Voeg in de methode Mainde volgende code toe:

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

Nu bent u klaar om uw eerste visualisator te testen.

De visualizer testen

Klik in Solution Explorer met de rechtermuisknop op MyTestConsole en kies Instellen als opstartproject in het snelmenu.
Kies op het menu Foutopsporing de optie Start.

De consoletoepassing wordt gestart en de Visualizer verschijnt en toont de tekenreeks "Hallo, wereld."

Gefeliciteerd. U hebt uw eerste visualisatie gebouwd en getest.

Als u uw visualisator in Visual Studio wilt gebruiken in plaats van deze alleen vanuit de testrunner aan te roepen, moet u deze installeren. Zie How to: Install a Visualizer (Een visualizer installeren) voor meer informatie.

Een gegevensobject aan de kant van de foutopsporing toevoegen

In deze sectie schakelt u over van het System.String gegevensobject naar een aangepast gegevensobject.

Klik in Solution Explorer met de rechtermuisknop op de oplossing, kies Toevoegen en selecteer vervolgens Nieuw project. Kies C# in de vervolgkeuzelijst taal. Typ de klassebibliotheek in het zoekvak en kies vervolgens Klassebibliotheek (.NET Framework) of Klassebibliotheek voor .NET Standard.

Opmerking

Als u een .NET Framework-testconsole-app gebruikt, moet u een .NET Framework-klassebibliotheekproject maken.
Kies Volgende. Typ in het dialoogvenster dat wordt weergegeven de naam MyDataObject, en selecteer vervolgens Maken.
(Alleen .NET Standard-klassebibliotheek) Klik in Solution Explorer met de rechtermuisknop op het project en kies Projectbestand bewerken. Wijzig de <TargetFramework> waarde in netstandard2.0.
```
<TargetFramework>netstandard2.0</TargetFramework>
```
Vervang in de MyDataObject naamruimte de standaardcode door de volgende code.
```
[Serializable] 
public class CustomDataObject
{
   public CustomDataObject()
   {
      this.MyData = "MyTestData";
   }
   public string MyData { get; set; }
}
```
Voor een alleen-lezen visualisatie, zoals in dit voorbeeld, is het niet nodig om methoden van VisualizerObjectSource te implementeren.

Werk vervolgens het project MyFirstVisualizer bij om het nieuwe gegevensobject te gebruiken.
Klik in Solution Explorer onder het project MyFirstVisualizer met de rechtermuisknop op het knooppunt Verwijzingen en kies Verwijzing toevoegen.
Selecteer onder Projecten het project MyDataObject .
Werk in de kenmerkcode van DebuggerSide.cs de doelwaarde bij naar System.StringMyDataObject.CustomDataObject.
```
Target = typeof(MyDataObject.CustomDataObject),
```
Vervang in het project MyFirstVisualizer de code voor de Show methode door de volgende code.
```
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);
```
In de voorgaande code wordt een eigenschap van het gegevensobject gebruikt om weer te geven in de titel van het formulier.

Werk vervolgens de console-app bij om het aangepaste gegevensobject te gebruiken.
Klik in Solution Explorer onder het project MyTestConsole met de rechtermuisknop op het knooppunt Verwijzingen of Afhankelijkheden en voeg een projectverwijzing toe aan MyDataObject.

Vervang in Program.cs de code in de Main methode door de volgende code.

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

DebuggerSide.TestShowVisualizer(customDataObject);

(.NET-console-app) Plaats de aanroep naar TestShowVisualizer in een try-catch-instructie, aangezien het testharnas niet ondersteund wordt.
```
try
{
      DebuggerSide.TestShowVisualizer(customDataObject);
}
catch (Exception) {
}
```
De console-app heeft een runtime-verwijzing naar de visualizer nodig. U kunt de verwijzing behouden door de voorgaande code te laten staan in plaats van deze uit te schakelen.
Voor een .NET Framework-console-app kunt u het testharnas uitvoeren (druk op F5) of u kunt de instructies volgen in How to: Install a Visualizer.

Als u de app uitvoert met behulp van het test-harnas, wordt het Windows-formulier weergegeven.
Kopieer voor een .NET-console-app de MyFirstVisualizer.dll en de MyDataObject.dll naar de mappen die worden beschreven in How to: Install a Visualizer.
Nadat u de visualizer hebt geïnstalleerd, stelt u een onderbrekingspunt in, voert u de console-app uit en beweegt u de muisaanwijzer over customDataObject. Als alles correct is ingesteld, ziet u het vergrootglaspictogram .

Wanneer u MyFirstVisualizer kiest in het vergrootglas, ziet u het formulier met de tekst van het gegevensobject in de titel.

Feedback

Is deze pagina nuttig?

Last updated on 2025-12-12