Freigeben über

Exemplarische Vorgehensweise: Schreiben einer Schnellansicht in Visual Basic

  • Artikel

Wichtig

Ab Visual Studio 2022 Version 17.9 können jetzt Visualizer in .NET 6.0+ geschrieben werden, die außerhalb des Prozesses unter Verwendung des neuen VisualStudio.Extensibility-Modells laufen. Wir empfehlen Visualizer-Autoren, die neue Dokumentation unter Visual Studio Debugger Visualizer erstellen zu referenzieren, es sei denn, sie möchten ältere Versionen von Visual Studio unterstützen oder ihre benutzerdefinierten Visualisierungen als Teil einer Bibliotheks-DLL ausliefern.

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie in Visual Basic eine einfache Schnellansicht schreiben können. Die in dieser exemplarischen Vorgehensweise erstellte Schnellansicht zeigt den Inhalt einer Zeichenfolge in einem Windows Forms-Meldungsfeld an. Nach dem Muster dieser einfachen Zeichenfolgen-Schnellansicht können Sie auch Schnellansichten für andere Datentypen erstellen, die Sie in Ihren Projekten benötigen.

Hinweis

Die angezeigten Dialogfelder und Menübefehle können sich je nach den aktiven Einstellungen oder der verwendeten Version von den in der Hilfe beschriebenen unterscheiden. Wählen Sie im Menü Extras die Option Importieren und Exportieren aus, um die Einstellungen zu ändern. Weitere Informationen finden Sie unter Reset settings (Zurücksetzen der Einstellungen).

Der Code für eine Schnellansicht muss in eine DLL eingefügt werden, die vom Debugger gelesen wird. Deshalb besteht der erste Schritt darin, ein Klassenbibliotheksprojekt für die DLL zu erstellen.

Erstellen und Vorbereiten eines Klassenbibliothekprojekts

So erstellen Sie ein Klassenbibliotheksprojekt

  1. Erstellen Sie ein neues Klassenbibliotheksprojekt.

    Drücken Sie ESC, um das Startfenster zu schließen. Geben Sie STRG+Q ein, um das Suchfeld zu öffnen, geben Sie visual basic ein, wählen Sie Vorlagen aus, und wählen Sie dann Create a new Class Library (.NET Framework) (Neue Klassenbibliothek erstellen (.NET Framework)) aus. Wählen Sie im angezeigten Dialogfeld Erstellen aus.

  2. Geben Sie einen geeigneten Namen für die Klassenbibliothek ein, z. B. MyFirstVisualizer, und klicken Sie dann auf Erstellen oder OK.

    Wenn Sie die Klassenbibliothek erstellt haben, müssen Sie einen Verweis auf Microsoft.VisualStudio.DebuggerVisualizers.DLL hinzufügen, damit die dort definierten Klassen verwendet werden können. Geben Sie dem Projekt zunächst jedoch einen aussagekräftigen Namen.

So benennen Sie "Class1.vb" um und fügen "Microsoft.VisualStudio.DebuggerVisualizers" hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Class1.vb und dann im Kontextmenü auf Umbenennen.

  2. Ändern Sie den Namen von Class1.vb in einen aussagekräftigeren Namen, zum Beispiel DebuggerSide.vb.

    Hinweis

    Visual Studio passt die Klassendeklaration in DebuggerSide.vb automatisch an den neuen Dateinamen an.

  3. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf MyFirstVisualizer, und klicken Sie dann im Kontextmenü auf Verweis hinzufügen.

  4. Wählen Sie im Dialogfeld Verweis hinzufügen auf der Registerkarte Durchsuchen den Eintrag Durchsuchen aus, und suchen Sie nach Microsoft.VisualStudio.DebuggerVisualizers.DLL.

    Sie finden die DLL im Unterverzeichnis <Visual Studio-Installationsverzeichnis>\Common7\IDE\PublicAssemblies des Installationsverzeichnisses von Visual Studio.

  5. Klicken Sie auf OK.

  6. Fügen Sie in DebuggerSide.vb den Imports-Anweisungen die folgende Anweisung hinzu:

    Imports Microsoft.VisualStudio.DebuggerVisualizers

Hinzufügen des Codes für den Debugger

Jetzt können Sie den Code für den Debugger erstellen. Dies ist der Code, der innerhalb des Debuggers ausgeführt wird, um die gewünschten Informationen anzuzeigen. Zuerst müssen Sie die Deklaration des DebuggerSide-Objekts ändern, sodass es von der DialogDebuggerVisualizer-Basisklasse erbt.

So lassen Sie das Objekt von "DialogDebuggerVisualizer" erben

  1. Navigieren Sie in DebuggerSide.vb zu folgender Codezeile:

    Public Class DebuggerSide

  2. Ändern Sie den Code folgendermaßen:

    Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

    Hinweis

    DialogDebuggerVisualizer erwartet ein FormatterPolicy-Argument im Konstruktor. Aufgrund der Sicherheitsprobleme, die in Besondere Überlegungen zur Debuggerseite für .NET 5.0 und höher beschrieben sind, können Visualizer ab Visual Studio 2022 Version 17.11 die Legacy-Formatierungsrichtlinie jedoch nicht mehr angeben.

    DialogDebuggerVisualizer verfügt über eine abstrakte Methode, Show, die Sie überschreiben müssen.

So überschreiben Sie die DialogDebuggerVisualizer.Show-Methode

  • Fügen Sie public class DebuggerSide folgende Methode hinzu:

    Protected Overrides Sub Show(ByVal windowService As Microsoft.VisualStudio.DebuggerVisualizers.IDialogVisualizerService, ByVal objectProvider As Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider)

    End Sub

    Die Show-Methode enthält den Code, der für das Erstellen des Dialogfelds der Schnellansicht oder eines anderen Benutzeroberflächenelements verantwortlich ist. Sie zeigt die Informationen an, die der Debugger an die Schnellansicht übergibt. Den Code, der das Dialogfeld erstellt und die Informationen anzeigt, müssen Sie hinzufügen. In dieser exemplarischen Vorgehensweise wird dazu ein Windows Forms-Meldungsfeld verwendet. Zuerst müssen Sie einen Verweis und eine Imports-Anweisung für System.Windows.Forms hinzufügen.

So fügen Sie System.Windows.Forms hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Verweise, und klicken Sie dann im Kontextmenü auf Verweis hinzufügen.

  2. Wählen Sie im Dialogfeld Verweis hinzufügen auf der Registerkarte Durchsuchen die Option Durchsuchen aus, und suchen Sie nach System.Windows.Forms.DLL.

    Sie finden die DLL unter C:\Windows\Microsoft.NET\Framework\v4.0.30319.

  3. Klicken Sie auf OK.

  4. Fügen Sie in DebuggerSide.cs den Imports-Anweisungen die folgende Anweisung hinzu:

    Imports System.Windows.Forms

Erstellen der Benutzeroberfläche der Schnellansicht

Als Nächstes fügen Sie Code hinzu, um die Benutzeroberfläche der Schnellansicht zu erstellen und anzuzeigen. Da dies Ihre erste Schnellansicht ist, halten wir die Benutzeroberfläche bewusst einfach und verwenden deshalb ein Meldungsfeld.

So zeigen Sie die Ausgabe der Schnellansicht in einem Dialogfeld an

  1. Fügen Sie der Show-Methode folgende Codezeile hinzu:

    MessageBox.Show(objectProvider.GetObject().ToString())

    Dieser Beispielcode enthält keine Fehlerbehandlung. Sie sollten die Fehlerbehandlung in einer echten Schnellansicht oder in anderen Anwendungen berücksichtigen.

  2. Klicken Sie im Menü Erstellen auf MyFirstVisualizer erstellen. Das Projekt sollte erfolgreich erstellt werden. Korrigieren Sie alle Buildfehler, bevor Sie fortfahren.

Hinzufügen des erforderlichen Attributs

Damit sind wir mit dem Code für den Debugger fertig. Ein Schritt fehlt allerdings noch: Das Attribut, das der zu debuggenden Seite mitteilt, welche Auflistung von Klassen die Schnellansicht enthält.

So fügen Sie den Typ hinzu, der für den zu debuggenden Code visualisiert werden soll

Geben Sie den zu visualisierenden Typ (die Objektquelle) für die zu debuggende Komponente mit dem DebuggerVisualizerAttribute-Attribut im debuggerseitigen Code an. Die Target-Eigenschaft legt den zu visualisierenden Typ fest.

  1. Fügen Sie DebuggerSide.vb den folgenden Attributcode hinzu, und zwar nach den Imports-Anweisungen und vor namespace MyFirstVisualizer:

    <Assembly: System.Diagnostics.DebuggerVisualizer(GetType(MyFirstVisualizer.DebuggerSide), GetType(VisualizerObjectSource), Target:=GetType(System.String), Description:="My First Visualizer")>

  2. Klicken Sie im Menü Erstellen auf MyFirstVisualizer erstellen. Das Projekt sollte erfolgreich erstellt werden. Korrigieren Sie alle Buildfehler, bevor Sie fortfahren.

Erstellen einer Testumgebung

Damit ist das Erstellen Ihrer ersten Schnellansicht abgeschlossen. Wenn Sie alle Schritte richtig befolgt haben, können Sie die Schnellansicht problemlos erstellen und in Visual Studio installieren. Bevor Sie eine Schnellansicht in Visual Studio installieren, sollten Sie jedoch durch Tests sicherstellen, dass sie ordnungsgemäß funktioniert. Als Nächstes erstellen Sie eine Testumgebung, in der Sie die Schnellansicht ohne Installation in Visual Studio ausführen können.

So fügen Sie eine Testmethode zur Anzeige der Schnellansicht hinzu

  1. Fügen Sie der public DebuggerSide-Klasse folgende Methode hinzu:

    Shared Public Sub TestShowVisualizer(ByVal objectToVisualize As Object)
    Dim visualizerHost As New VisualizerDevelopmentHost(objectToVisualize, GetType(DebuggerSide))
visualizerHost.ShowVisualizer()
End Sub

  2. Klicken Sie im Menü Erstellen auf MyFirstVisualizer erstellen. Das Projekt sollte erfolgreich erstellt werden. Korrigieren Sie alle Buildfehler, bevor Sie fortfahren.

    Als Nächstes müssen Sie ein ausführbares Projekt erstellen, um die Schnellansichts-DLL aufzurufen. Verwenden Sie der Einfachheit halber ein Konsolenanwendungsprojekt.

So fügen Sie der Projektmappe ein Konsolenanwendungsprojekt hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, und wählen Sie Hinzufügen und dann Neues Projekt aus.

    Geben Sie im Suchfeld visual basic ein, wählen Sie Vorlagen aus, und wählen Sie dann Create a new Console App (.NET Framework) (Neue Konsolen-App erstellen (.NET Framework)) aus. Wählen Sie im angezeigten Dialogfeld Erstellen aus.

  2. Geben Sie einen geeigneten Namen für die Klassenbibliothek ein, z. B. MyTestConsole, und klicken Sie dann auf Erstellen oder OK.

    Jetzt müssen Sie die notwendigen Verweise hinzufügen, damit MyFirstVisualizer von MyTestConsole aufgerufen werden kann.

So fügen Sie MyTestConsole die erforderlichen Verweise hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf MyTestConsole, und klicken Sie dann im Kontextmenü auf Verweis hinzufügen.

  2. Klicken Sie im Dialogfeld Verweis hinzufügen auf der Registerkarte Durchsuchen auf Microsoft.VisualStudio.DebuggerVisualizers.

  3. Klicken Sie auf OK.

  4. Klicken Sie mit der rechten Maustaste auf MyTestConsole, und klicken Sie erneut auf Verweis hinzufügen.

  5. Klicken Sie im Dialogfeld Verweis hinzufügen auf die Registerkarte Projekte, und wählen Sie dann „MyFirstVisualizer“ aus.

  6. Klicken Sie auf OK.

Fertigstellen der Testumgebung und Testen der Schnellansicht

Als Nächstes fügen Sie den Code hinzu und stellen damit die Testumgebung fertig.

So fügen Sie MyTestConsole Code hinzu

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Program.vb und dann im Kontextmenü auf Umbenennen.

  2. Ändern Sie den Namen „Module1.vb“ in einen passenden Namen, z.B. TestConsole.vb.

    Visual Studio passt die Klassendeklaration in TestConsole.vb automatisch an den neuen Dateinamen an.

  3. Fügen Sie in „TestConsole. vb“ Sie die folgende Imports-Anweisung hinzu:

    Imports MyFirstVisualizer

  4. Fügen Sie der Main-Methode den folgenden Code hinzu:

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

    Jetzt können Sie Ihre erste Schnellansicht testen.

So testen Sie die Schnellansicht

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf MyTestConsole, und klicken Sie im Kontextmenü auf Als Startprojekt festlegen.

  2. Klicken Sie im Menü Debuggen auf Starten.

    Die Konsolenanwendung wird gestartet. Die Schnellansicht wird mit der Zeichenfolge "Hello, World" angezeigt.

    Herzlichen Glückwunsch! Sie haben soeben Ihre erste Schnellansicht erstellt und getestet.

    Wenn Sie die Schnellansicht in Visual Studio und nicht nur innerhalb der Testumgebung verwenden möchten, dann müssen Sie sie installieren. Weitere Informationen finden Sie unter Vorgehensweise: Install a Visualizer (Vorgehensweise: Installieren einer Schnellansicht).

Zugehöriger Inhalt