Architecture d'un visualiseur
L'architecture d'un visualiseur du débogueur comporte deux parties :
Le côté débogueur s'exécute dans le débogueur Visual Studio. Le code côté débogueur crée et affiche l'interface utilisateur de votre visualiseur.
Le côté programme débogué s'exécute dans le processus que Visual Studio débogue (le programme débogué).
Un visualiseur est un composant du débogueur qui permet à ce dernier d'afficher (de visualiser) le contenu d'un objet de données sous forme explicite, compréhensible. Certains visualiseurs prennent également en charge la modification de l'objet de données. En écrivant des visualiseurs personnalisés, vous pouvez étendre les fonctionnalités du débogueur afin de gérer vos propres types de données personnalisés.
L'objet de données à visualiser réside dans le processus que vous déboguez (processus du programme débogué ). L'interface utilisateur qui affiche les données est créée dans le processus du débogueur Visual Studio :
Processus du débogueur |
Processus du programme débogué |
|---|---|
Interface utilisateur du débogueur (DataTips, fenêtre Espion, Espion express) |
Objet de données à visualiser |
Pour visualiser l'objet de données dans l'interface du débogueur, vous avez besoin de code afin d'établir une communication entre les deux processus. Par conséquent, l'architecture du visualiseur se compose de deux parties : code côté débogueur et code côté programme débogué.
Le code côté débogueur crée sa propre interface utilisateur, laquelle peut être appelée à partir de l'interface du débogueur, par exemple un DataTip, la fenêtre Espion ou l'Espion express. L'interface du visualiseur est créée via la classe DialogDebuggerVisualizer et l'interface IDialogVisualizerService. Comme toutes les API du visualiseur, DialogDebuggerVisualizer et IDialogVisualizerService se trouvent dans l'espace de noms Microsoft.VisualStudio.DebuggerVisualizers.
Côté débogueur |
Côté programme débogué |
|---|---|
Classe DialogDebuggerVisualizer Interface IDialogVisualizerService |
Objet de données |
L'interface utilisateur obtient les données à visualiser à partir d'un fournisseur d'objets, qui existe côté débogueur :
Côté débogueur |
Côté programme débogué |
|---|---|
Classe DialogDebuggerVisualizer Interface IDialogVisualizerService |
Objet de données |
Fournisseur d'objets (implémente IVisualizerObjectProvider) |
Il y a un objet correspondant côté programme débogué, que l'on appelle source de l'objet :
Côté débogueur |
Côté programme débogué |
|---|---|
Classe DialogDebuggerVisualizer Interface IDialogVisualizerService |
Objet de données |
Fournisseur d'objets (implémente IVisualizerObjectProvider) |
Source de l'objet (dérivée de VisualizerObjectSource) |
Le fournisseur d'objets fournit les données d'objet qui seront visualisées via l'interface utilisateur du visualiseur. Le fournisseur d'objets obtient les données d'objet à partir de la source de l'objet. Le fournisseur d'objets et la source de l'objet fournissent des API pour permettre la communication des données d'objet entre le débogueur et le programme débogué.
Chaque visualiseur doit obtenir l'objet de données à visualiser. Le tableau suivant affiche les API correspondantes utilisées à cet effet par le fournisseur d'objets et la source de l'objet :
Fournisseur d'objets |
Source de l'objet |
|---|---|
|
- ou - |
Notez que le fournisseur d'objets peut utiliser GetData ou GetObject. Les deux API entraînent l'appel de GetData sur la source de l'objet. Un appel à VisualizerObjectSource.GetData remplit un [System.IO.Stream] qui représente une forme sérialisée de l'objet visualisé.
IVisualizerObjectProvider.GetObject désérialise les données sous forme d'objet que vous pouvez ensuite afficher dans l'interface utilisateur créée à l'aide de DialogDebuggerVisualizer. IVisualizerObjectProvider.GetData remplit les données sous forme de [System.IO.Stream] brut, que vous devez désérialiser vous-même. IVisualizerObjectProvider.GetObject fonctionne en appelant IVisualizerObjectProvider.GetData pour obtenir le [System.IO.Stream] sérialisé, puis en désérialisant les données. Utilisez IVisualizerObjectProvider.GetData lorsque l'objet n'est pas sérialisable par le .NET et qu'il requiert une sérialisation personnalisée. Dans ce cas, vous devez également substituer la méthode VisualizerObjectSource.Serialize.
Si vous créez un visualiseur en lecture seule, une communication unidirectionnelle avec GetData ou GetObject suffit. Si vous créez un visualiseur qui prend en charge la modification des objets de données, vous devez effectuer des tâches supplémentaires. Vous devez également être en mesure de renvoyer un objet de données du fournisseur d'objets à la source de l'objet. Le tableau suivant affiche les API utilisées à cet effet par le fournisseur d'objets et la source de l'objet :
Fournisseur d'objets |
Source de l'objet |
|---|---|
|
- ou - |
Notez à nouveau qu'il y a deux API utilisables par le fournisseur d'objets. Les données sont toujours envoyées du fournisseur d'objets à la source de l'objet en tant que [System.IO.Stream] ; toutefois, ReplaceData requiert que vous sérialisiez vous-même l'objet en [System.IO.Stream].
ReplaceObject accepte un objet que vous fournissez, le sérialise en [System.IO.Stream], puis appelle ReplaceData pour envoyer [System.IO.Stream] vers CreateReplacementObject.
L'utilisation de l'une des méthodes Replace entraîne la création d'un objet de données dans le programme débogué, qui remplace l'objet visualisé. Si vous souhaitez modifier le contenu de l'objet d'origine sans le remplacer, utilisez l'une des méthodes Transfer figurant dans le tableau ci-après. Ces API transfèrent les données dans les deux sens et en même temps, sans remplacer l'objet visualisé :
Fournisseur d'objets |
Source de l'objet |
|---|---|
|
- ou - |
Voir aussi
Tâches
Comment : écrire un visualiseur
Procédure pas à pas : écriture d'un visualiseur en C#
Procédure pas à pas : écriture d'un visualiseur en Visual Basic
Procédure pas à pas : écriture d'un visualiseur en Visual Basic