Compartir a través de

Tutorial: Escritura un visualizador en Visual Basic

  • Artículo

Importante

A partir de la versión 17.9 de Visual Studio 2022, los visualizadores se pueden escribir en .NET 6.0+, que se ejecuta fuera de proceso mediante el nuevo modelo VisualStudio.Extensibility. Animamos a los autores de visualizadores a hacer referencia a la nueva documentación en Creación de visualizadores del depurador de Visual Studio a menos que quieran admitir versiones anteriores de Visual Studio o que quieran enviar sus visualizadores personalizados como parte de un archivo DLL de biblioteca.

En este tutorial se muestra cómo escribir un visualizador sencillo con Visual Basic. El visualizador que creará en este tutorial muestra el contenido de una cadena mediante un cuadro de mensaje de formularios Windows Forms. Este sencillo visualizador de cadenas es un ejemplo básico que muestra cómo se pueden crear visualizadores para otros tipos de datos más aplicables a sus proyectos.

Nota

Los cuadros de diálogo y los comandos de menú que se ven pueden diferir de los descritos en la Ayuda, dependiendo de los valores de configuración o de edición activos. Para cambiar la configuración, vaya al menú Herramientas y elija Importar y exportar. Para obtener más información, vea Restablecer la configuración.

El código del visualizador debe colocarse en un archivo DLL que leerá el depurador. El primer paso es crear un proyecto de biblioteca de clases para el archivo DLL.

Crear y preparar un proyecto de biblioteca de clases

Para crear un proyecto de biblioteca de clases

  1. Cree un nuevo proyecto de biblioteca de clases.

    Presione Esc para cerrar la ventana de inicio. Presione Ctrl + Q para abrir el cuadro de búsqueda, escriba visual basic, elija Plantillas y luego, Crear una nueva biblioteca de clases (.NET Framework) . En el cuadro de diálogo que se abre, elija Crear.

  2. Escriba un nombre adecuado para la biblioteca de clases, como MyFirstVisualizer, y haga clic en Crear o Aceptar.

    Cuando haya creado la biblioteca de clases, debe agregar una referencia a Microsoft.VisualStudio.DebuggerVisualizers.DLL, para que pueda utilizar las clases que allí se definen. No obstante, en primer lugar debe asignar un nombre descriptivo al proyecto.

Para cambiar el nombre de Class1.vb y agregar Microsoft.VisualStudio.DebuggerVisualizers

  1. En el Explorador de soluciones, haga clic con el botón derecho en Class1.vb y, en el menú contextual, haga clic en Cambiar nombre.

  2. Cambie el nombre Class1.vb por un nombre significativo, como DebuggerSide.vb.

    Nota

    Visual Studio cambia automáticamente la declaración de clase en DebuggerSide.vb para que coincida con el nuevo nombre del archivo.

  3. En el Explorador de soluciones, haga clic con el botón derecho en Mi primer visualizador y, a continuación, haga clic en Agregar referencia en el menú contextual.

  4. En el cuadro de diálogo Agregar referencia, en la pestaña Examinar, seleccione Examinar y busque Microsoft.VisualStudio.DebuggerVisualizers.DLL.

    Puede encontrar el archivo DLL en el subdirectorio <Visual Studio Install Directory>\Common7\IDE\PublicAssemblies del directorio de instalación de Visual Studio.

  5. Haga clic en Aceptar.

  6. En DebuggerSide.vb, agregue la instrucción siguiente a las instrucciones Imports:

    Imports Microsoft.VisualStudio.DebuggerVisualizers

Agregar el código depurado

Ahora, ya está listo para crear el código del depurador. Éste es el código que se ejecuta dentro del depurador para mostrar la información que desea visualizar. En primer lugar hay que cambiar la declaración del objeto DebuggerSide para que herede de la clase base DialogDebuggerVisualizer.

Para heredar de DialogDebuggerVisualizer

  1. En DebuggerSide.vb, vaya a la línea siguiente del código:

    Public Class DebuggerSide

  2. Edite el código de forma que presente el siguiente aspecto:

    Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

    Nota:

    DialogDebuggerVisualizer espera un argumento FormatterPolicy en su constructor. Sin embargo, debido a los problemas de seguridad descritos en Consideraciones especiales del lado depurador para .NET 5.0+, a partir de Visual Studio 2022 versión 17.11, los visualizadores no podrán especificar la directiva de formateador Legacy.

    DialogDebuggerVisualizer tiene un método abstracto, Show, que debe reemplazar.

Para reemplazar el método DialogDebuggerVisualizer.Show

  • En public class DebuggerSide, agregue el método siguiente:

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

    End Sub

    El método Show contiene el código que verdaderamente crea el cuadro de diálogo del visualizador, u otra interfaz de usuario, y muestra la información que se ha pasado del depurador al visualizador. Es necesario agregar el código que crea el cuadro de diálogo y muestra la información. En este tutorial, se realizará este paso mediante un cuadro de mensaje de formularios Windows Forms. En primer lugar debe agregar una referencia y una instrucción Imports para System.Windows.Forms.

Para agregar System.Windows.Forms

  1. En el Explorador de soluciones, haga clic con el botón derecho en Referencias y, a continuación, haga clic en Agregar referencia en el menú contextual.

  2. En el cuadro de diálogo Agregar referencia, en la pestaña Examinar, seleccione Examinar y busque System.Windows.Forms.DLL.

    Puede encontrar el archivo DLL en C:\Windows\Microsoft.NET\Framework\v4.0.30319.

  3. Haga clic en Aceptar.

  4. En DebuggerSide.cs, agregue la instrucción siguiente a las instrucciones Imports:

    Imports System.Windows.Forms

Crear la interfaz de usuario del visualizador

Ahora, agregará código para crear y mostrar la interfaz de usuario para el visualizador. Debido que éste es su primer visualizador, mantendrá la interfaz de usuario sencilla y utilizará un cuadro de mensaje.

Para mostrar el resultado del visualizador en un cuadro de diálogo

  1. En el método Show, agregue la siguiente línea de código:

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

    En este código de ejemplo no se incluye el control de errores. Debe incluir el control de errores en un visualizador real o en cualquier otro tipo de aplicación.

  2. En el menú Compilar, haga clic en Compilar MyFirstVisualizer. El proyecto debería compilarse correctamente. Corrija cualquier error de compilación antes de continuar.

Agregar el atributo necesario

Ése es el fin del código del depurador. Sin embargo, hay un paso más que realizar: el atributo que indica al lado depurado qué colección de clases incluye el visualizador.

Para agregar el tipo que se va a visualizar en el código del lado depurado

En el código del depurador, especifique el tipo que se va a visualizar (el origen del objeto) en el lado depurado con el atributo DebuggerVisualizerAttribute. La propiedad Target establece el tipo que se va a visualizar.

  1. Agregue el código de atributo siguiente a DebuggerSide.vb, después de las instrucciones Imports, pero antes de namespace MyFirstVisualizer:

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

  2. En el menú Compilar, haga clic en Compilar MyFirstVisualizer. El proyecto debería compilarse correctamente. Corrija cualquier error de compilación antes de continuar.

Crear un instrumento de prueba

En este momento, el primer visualizador está terminado. Si ha seguido los pasos correctamente, debería poder compilar el visualizador e instalarlo en Visual Studio. Sin embargo, antes de instalar un visualizador en Visual Studio, debería probarlo para asegurarse de que se ejecuta correctamente. A continuación creará un instrumento de prueba para ejecutar el visualizador sin instalarlo en Visual Studio.

Para agregar un método de prueba para mostrar el visualizador

  1. Agregue el método siguiente a la clase public DebuggerSide:

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

  2. En el menú Compilar, haga clic en Compilar MyFirstVisualizer. El proyecto debería compilarse correctamente. Corrija cualquier error de compilación antes de continuar.

    Luego, debe crear un proyecto ejecutable para llamar al archivo DLL del visualizador. Para que resulte más sencillo, utilice un proyecto de aplicación de consola.

Para agregar un proyecto de aplicación de consola a la solución

  1. En el Explorador de soluciones, haga clic con el botón derecho en la solución; luego, elija Agregar y haga clic en Nuevo proyecto.

    En el cuadro de búsqueda, escriba visual basic, elija Plantillas y, luego, Create a new Console App (.NET Framework) [Crear una nueva aplicación de consola (.NET Framework)]. En el cuadro de diálogo que se abre, elija Crear.

  2. Escriba un nombre adecuado para la biblioteca de clases, como MyTestConsole, y haga clic en Crear o Aceptar.

    Ahora, debe agregar las referencias necesarias para que MyTestConsole pueda llamar a MyFirstVisualizer.

Para agregar las referencias necesarias a MyTestConsole

  1. En el Explorador de soluciones, haga clic con el botón derecho en MyTestConsole y, luego, en Agregar referencia, en el menú contextual.

  2. En el cuadro de diálogo Agregar referencia, en la pestaña Examinar, haga clic en Microsoft.VisualStudio.DebuggerVisualizers.

  3. Haga clic en Aceptar.

  4. Haga clic con el botón derecho en MyTestConsole y, a continuación, vuelva a hacer clic en Agregar referencia.

  5. En el cuadro de diálogo Agregar referencia, haga clic en la pestaña Proyectos y, a continuación, seleccione MyFirstVisualizer.

  6. Haga clic en Aceptar.

Finalizar el instrumento de prueba y probar el visualizador

A continuación, agregará el código para finalizar el instrumento de prueba.

Para agregar el código a MyTestConsole

  1. En el Explorador de soluciones, haga clic con el botón derecho en Program.vb y, en el menú contextual, haga clic en Cambiar nombre.

  2. Edite el nombre de Module1.vb por uno adecuado, como por ejemplo TestConsole.vb.

    Tenga en cuenta que Visual Studio cambia automáticamente la declaración de clase de TestConsole.vb para que coincida con el nuevo nombre de archivo.

  3. En TestConsole. vb, agregue la instrucción Imports siguiente:

    Imports MyFirstVisualizer

  4. En el método Main, agregue el código siguiente:

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

    Ahora está preparado para probar el primer visualizador.

Para probar el visualizador

  1. En el Explorador de soluciones, haga clic con el botón derecho en MyTestConsole y, en el menú contextual, en Establecer como proyecto de inicio.

  2. En el menú Depurar, haga clic en Iniciar.

    Se inicia la aplicación de consola. Aparecerá el visualizador y mostrará la cadena "Hello, World".

    Enhorabuena. Acaba de compilar y probar el primer visualizador.

    Si desea utilizar el visualizador en Visual Studio, en lugar de simplemente llamarlo desde el instrumento de prueba, tendrá que instalarlo. Para obtener más información, vea Cómo: instalar un visualizador.

Contenido relacionado