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é élément débogué s’exécute dans le processus que Visual Studio débogue (l’élément 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 une forme explicite et 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 de l’élément 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é élément 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é élément 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é élément 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é élément 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 communiquer les données d’objet entre le débogueur et l’élément 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 |
|---|---|
| GetData Ou GetObject |
GetData |
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 à Microsoft.VisualStudio.DebuggerVisualizers.VisualizerObjectSource.GetData remplit un System.IO.Stream qui représente une forme sérialisée de l'objet visualisé.
Microsoft.VisualStudio.DebuggerVisualizers.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. Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider.GetData remplit les données sous forme de Stream brut, que vous devez désérialiser vous-même. Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider.GetObject fonctionne en appelant Microsoft.VisualStudio.DebuggerVisualizers.IVisualizerObjectProvider.GetData pour obtenir le Stream sérialisé, puis en désérialisant les données. Utilisez Microsoft.VisualStudio.DebuggerVisualizers.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 Microsoft.VisualStudio.DebuggerVisualizers.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 |
|---|---|
| ReplaceData Ou ReplaceObject |
CreateReplacementObject |
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 Stream ; toutefois, ReplaceData requiert que vous sérialisiez vous-même l'objet en Stream.
ReplaceObject accepte un objet que vous fournissez, le sérialise en Stream, puis appelle ReplaceData pour envoyer Stream vers CreateReplacementObject.
L’utilisation de l’une des méthodes Replace entraîne la création d’un objet de données dans l’élément 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 |
|---|---|
| TransferData Ou TransferObject |
TransferData |