Procédure pas à pas : écriture d'un visualiseur en Visual Basic

Article
06/10/2015

Cette procédure pas à pas explique comment écrire un visualiseur simple à l'aide de Visual Basic. Le visualiseur que permet de créer cette procédure pas à pas affiche le contenu d'une chaîne à l'aide d'un message Windows Forms. Ce visualiseur de chaîne simple est un exemple de base qui vous montre comment vous pouvez créer des visualiseurs pour d'autres types de données plus applicables à vos projets.

Notes

Les boîtes de dialogue et les commandes de menu qui s'affichent peuvent être différentes de celles qui sont décrites dans l'aide, en fonction de vos paramètres actifs ou de l'édition utilisée.Pour modifier vos paramètres, dans le menu Outils, cliquez sur Importer et exporter.Pour plus d'informations, consultez Paramètres Visual Studio.

Le code du visualiseur doit être placé dans une DLL qui sera lue par le débogueur. La première étape consiste à créer un projet de bibliothèque de classes pour la DLL.

Créer et préparer un projet Bibliothèque de classes

Pour créer un projet Bibliothèque de classes

Dans le menu Fichier, cliquez sur Nouveau, puis sur Nouveau projet.
Dans la boîte de dialogue Nouveau projet, sous Type de projet, cliquez sur Visual Basic.
Dans la zone Modèles, cliquez sur Bibliothèque de classes.
Dans la zone Nom, tapez un nom approprié pour la bibliothèque de classes, par exemple MyFirstVisualizer.
Cliquez sur OK.

Une fois que vous avez créé la bibliothèque de classes, vous devez ajouter une référence à Microsoft.VisualStudio.DebuggerVisualizers.DLL afin de pouvoir utiliser les classes qui y sont définies. Pourtant, en premier lieu, donnez un nom significatif à votre projet.

Pour renommer Class1.vb et ajouter Microsoft.VisualStudio.DebuggerVisualizers

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Class1.vb et cliquez sur Renommer dans le menu contextuel.
Remplacez le nom Class1.vb par un nom explicite, par exemple DebuggerSide.vb.

Notes

Visual Studio remplace automatiquement le nom de la déclaration de classe par DebuggerSide.vb correspondant au nouveau nom du fichier.
Dans l'Explorateur de solutions, cliquez avec le bouton droit sur My First Visualizer, puis cliquez dans le menu contextuel sur Ajouter une référence.
Dans la boîte de dialogue Ajouter une référence, sous l'onglet .NET, cliquez sur Microsoft.VisualStudio.DebuggerVisualizers.DLL.
Cliquez sur OK.
Dans DebuggerSide.vb, ajoutez l'instruction suivante aux instructions Imports :
```
Imports Microsoft.VisualStudio.DebuggerVisualizers
```

Ajouter le code côté débogueur

Vous êtes désormais prêt à créer du code côté débogueur. Il s'agit du code qui s'exécute dans le débogueur pour afficher les informations que vous souhaitez consulter. Tout d'abord, vous devez modifier la déclaration de l'objet DebuggerSide afin qu'il hérite de la classe de base DialogDebuggerVisualizer.

Pour hériter de DialogDebuggerVisualizer

Dans DebuggerSide.vb, allez à la ligne de code suivante :
```
Public Class DebuggerSide
```

Modifiez le code pour qu'il se présente comme suit :

Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

DialogDebuggerVisualizer a une méthode abstraite, Show, que vous devez substituer.

Pour substituer la méthode DialogDebuggerVisualizer.Show

Dans public class DebuggerSide, ajoutez la méthode suivante :

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

    End Sub

La méthode Show contient le code qui crée en fait la boîte de dialogue du visualiseur, ou une autre interface utilisateur, et qui affiche les informations passées du débogueur au visualiseur. Vous devez ajouter le code qui crée la boîte de dialogue et affiche les informations. Cette procédure pas à pas vous montre comment y parvenir à l'aide d'un message Windows Forms. Vous devez d'abord ajouter une référence et une instruction Imports pour System.Windows.Forms.

Pour ajouter System.Windows.Forms

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Références, puis cliquez dans le menu contextuel sur Ajouter une référence.
Dans la boîte de dialogue Ajouter une référence, sous l'onglet .NET, cliquez sur System.Windows.Forms.
Cliquez sur OK.
Dans DebuggerSide.cs, ajoutez l'instruction suivante aux instructions Imports :
```
Imports System.Windows.Forms
```

Créer l'interface utilisateur de votre visualiseur

Puis, vous ajoutez du code pour créer et afficher l'interface utilisateur du visualiseur. Comme il s'agit de votre premier visualiseur, vous simplifierez l'interface utilisateur simple et utiliserez un message.

Pour afficher la sortie du visualiseur dans une boîte de dialogue

Dans la méthode Show, ajoutez la ligne de code suivante :
```
MessageBox.Show(objectProvider.GetObject().ToString())
```
Cet exemple de code n'inclut pas la gestion des erreurs. Vous devez inclure la gestion des erreurs dans un véritable visualiseur ou tout autre type d'application.
Dans le menu Générer, cliquez sur Build MyFirstVisualizer. Le projet doit se générer avec succès. Corrigez toutes les erreurs de build avant de continuer.

Ajouter l'attribut nécessaire

C'est la fin du code côté débogueur. Il existe toutefois une étape supplémentaire : ajouter l'attribut qui indique côté programme débogué la collection de classes qui compose le visualiseur.

Pour ajouter le code côté débogué

Ajoutez le code d'attribut suivant à DebuggerSide.vb, après les instructions Imports, mais avant namespace MyFirstVisualizer :

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

Dans le menu Générer, cliquez sur Build MyFirstVisualizer. Le projet doit se générer avec succès. Corrigez toutes les erreurs de build avant de continuer.

Créer un atelier de test

À ce stade, votre premier visualiseur est terminé. Si vous avez suivi les étapes correctement, vous devez être en mesure de générer le visualiseur et de l'installer dans Visual Studio. Toutefois, avant d'installer un visualiseur dans Visual Studio, vous devez le tester pour vous assurer qu'il s'exécute correctement. À présent, vous devez créer un atelier de test pour exécuter le visualiseur sans l'installer dans Visual Studio.

Pour ajouter une méthode de test permettant d'afficher le visualiseur

Ajoutez la méthode suivante à la classe public DebuggerSide:

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

Dans le menu Générer, cliquez sur Build MyFirstVisualizer. Le projet doit se générer avec succès. Corrigez toutes les erreurs de build avant de continuer.

Ensuite, vous devez créer un projet exécutable pour appeler la DLL du visualiseur. Par souci de simplicité, utilisez un projet d'application console.

Pour ajouter un projet d'application console à la solution

Dans le menu Fichier, pointez sur Ajouter, puis cliquez sur Nouveau projet.
Dans la boîte de dialogue Ajouter un nouveau projet, dans le volet Modèles, cliquez sur Application console.
Dans la zone Nom, tapez un nom significatif pour l'application console, par exemple MyTestConsole.
Cliquez sur OK.

Puis, vous devez ajouter les références nécessaires afin que MyTestConsole puisse appeler MyFirstVisualizer.

Pour ajouter les références nécessaires à MyTestConsole

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur MyTestConsole, puis cliquez dans le menu contextuel sur Ajouter une référence.
Dans la boîte de dialogue Ajouter une référence, sous l'onglet .NET, cliquez sur Microsoft.VisualStudio.DebuggerVisualizers.
Cliquez sur OK.
Cliquez avec le bouton droit sur MyTestConsole, puis cliquez sur Ajouter une référence.
Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet Projets, puis sélectionnez MyFirstVisualizer.
Cliquez sur OK.

Terminer votre atelier de test et tester votre visualiseur

Puis, vous ajoutez le code pour terminer l'atelier de test.

Pour ajouter le code à MyTestConsole

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur Program.vb et cliquez sur Renommer dans le menu contextuel.
Remplacez le nom Module1.vb par un nom approprié, tel que TestConsole.vb.

Notez que Visual Studio remplace automatiquement le nom de la déclaration de classe par TestConsole.vb correspondant au nouveau nom du fichier.
Dans TestConsole. vb, ajoutez l'instruction Imports suivante :
```
Imports MyFirstVisualizer
```

Dans la méthode Main, ajoutez le code suivant :

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

Vous êtes désormais prêt à tester votre premier visualiseur.

Pour tester le visualiseur

Dans l'Explorateur de solutions, cliquez avec le bouton droit sur MyTestConsole, puis cliquez sur Définir comme projet de démarrage dans le menu contextuel.
Dans le menu Déboguer, cliquez sur Démarrer.

L'application console démarre. Le visualiseur apparaît et affiche la chaîne « Hello, World ».

Félicitations ! Vous venez de générer et de tester votre premier visualiseur.

Pour utiliser votre visualiseur dans Visual Studio au lieu de simplement l'appeler de l'atelier de test, vous devez l'installer. Pour plus d'informations, consultez Comment : installer un visualiseur.

Voir aussi

Partager via