Compartilhar via

Instruções passo a passo: escrevendo um visualizador no Visual Basic

  • Artigo

Importante

A partir do Visual Studio 2022 versão 17.9, os visualizadores podem ser escritos em .NET 6.0+ que são executados fora do processo usando o novo modelo VisualStudio.Extensibility. Incentivamos os autores de visualizadores a fazer referência à nova documentação em Criar visualizadores de depurador do Visual Studio, a menos que desejem oferecer suporte a versões mais antigas do Visual Studio ou desejem enviar seus visualizadores personalizados como parte de uma DLL de biblioteca.

Este passo a passo mostra como escrever um visualizador simples usando Visual Basic. O visualizador que você criará neste passo a passo exibe o conteúdo de uma cadeia de caracteres usando uma caixa de mensagem do Windows Forms. Esse visualizador simples de cadeia de caracteres é um exemplo básico para mostrar como você pode criar visualizadores para outros tipos de dados mais aplicáveis a seus projetos.

Observação

As caixas de diálogo e os comandos do menu que você vê podem ser diferentes dos descritos na Ajuda, dependendo da edição ou das configurações ativas. Para alterar suas configurações, acesse o menu Ferramentas e escolha Importar e Exportar. Para obter mais informações, confira Redefinir as configurações.

O código do visualizador deve ser colocado em uma DLL, que será lido pelo depurador. A primeira etapa é criar um projeto da biblioteca de classes para a DLL.

Criar e preparar um projeto da biblioteca de classes

Para criar um projeto de biblioteca de classe

  1. Crie um novo projeto de biblioteca de classes.

    Pressione Esc para fechar a janela de início. Digite Ctrl + Q para abrir a caixa de pesquisa, digite visual basic, escolha Modelos e, em seguida, escolha Criar uma nova biblioteca de classes (.NET Framework). Na caixa de diálogo que aparece, escolha Criar.

  2. Digite um nome apropriado para a biblioteca de classes, como MyFirstVisualizer, e clique em Criar ou OK.

    Quando você criou a biblioteca de classes, você deverá adicionar uma referência a Microsoft.VisualStudio.DebuggerVisualizers.DLL de forma que possa usar as classes definidas nela. Primeiro, no entanto, dê ao seu projeto um nome significativo.

Para renomear Class1.vb e adicionar Microsoft.VisualStudio.DebuggerVisualizers

  1. No Gerenciador de Soluções, clique com o botão direito do mouse em Class1.vb e no menu de atalho, clique em Renomear.

  2. Altere o nome de Class1.vb para algo significativo, por exemplo, DebuggerSide.vb.

    Observação

    O Visual Studio automaticamente altera a declaração de classes em DebuggerSide.vb para corresponder ao novo nome do arquivo.

  3. No Gerenciador de Soluções, clique com o botão direito do mouse em Meu Primeiro Visualizador e, no menu de atalho, clique em Adicionar Referência.

  4. Na caixa de diálogo Adicionar Referência, na guia Procurar, selecione Procurar e localize o Microsoft.VisualStudio.DebuggerVisualizers.DLL.

    Você pode encontrar a DLL no <Diretório de Instalação do Visual Studio>\Common7\IDE\PublicAssemblies subdiretório do diretório de instalação do Visual Studio.

  5. Clique em OK.

  6. Em DebuggerSide.vb, adicione a seguinte instrução às instruções Imports:

    Imports Microsoft.VisualStudio.DebuggerVisualizers

Adicionar o código do lado do depurador

Agora você está pronto para criar o código do lado do depurador. Este é o código executado no depurador para exibir as informações que você deseja visualizar. Primeiro, você tem que alterar a declaração do objeto DebuggerSide de forma que ele herde da classe base DialogDebuggerVisualizer.

Para herdar de DialogDebuggerVisualizer

  1. Em DebuggerSide.vb, vá para a seguinte linha de código:

    Public Class DebuggerSide

  2. Edite o código de forma que tenha esta aparência:

    Public Class DebuggerSide
Inherits DialogDebuggerVisualizer

    Observação

    DialogDebuggerVisualizer espera um argumento FormatterPolicy em seu construtor. No entanto, devido aos problemas de segurança descritos em Considerações especiais do lado do depurador para o .NET 5.0+, a partir do Visual Studio 2022 versão 17.11, os visualizadores não poderão especificar a política Legacy do formatador.

    DialogDebuggerVisualizer tem um método abstrato Show que você deve substituir.

Para substituir o método DialogDebuggerVisualizer.Show

  • Em public class DebuggerSide, adicione o seguinte método:

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

    End Sub

    O método Show contém o código que realmente cria a caixa de diálogo DO visualizador ou outra interface de usuário e exibe as informações que foram passadas para o visualizador do depurador. Adicione o código que cria a caixa de diálogo e exibe as informações. Neste passo a passo, você fará isso usando uma caixa de mensagem do Windows Forms. Primeiro, você deve adicionar uma referência e uma instrução Imports para System.Windows.Forms.

Para adicionar System.Windows.Forms

  1. No Gerenciador de Soluções, clique com o botão direito do mouse em Referências e, no menu de atalho, clique em Adicionar Referência.

  2. Na caixa de diálogo Adicionar Referência, na guia Procurar, selecione Procurar e localize o System.Windows.Forms.DLL.

    Você pode encontrar a DLL em C:\Windows\Microsoft.NET\Framework\v4.0.30319.

  3. Clique em OK.

  4. Em DebuggerSide.cs, adicione a seguinte instrução às instruções Imports:

    Imports System.Windows.Forms

Criar a interface de usuário do visualizador

Agora, você adicionará um código para criar e exibir a interface de usuário para o visualizador. Como esse é o primeiro visualizador, você manterá a interface do usuário simples e usará uma caixa de mensagem.

Para mostrar a saída do visualizador em uma caixa de diálogo

  1. No método Show, adicione a linha de código a seguir:

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

    Esse código de exemplo não inclui tratamento de erros. Você deve incluir o tratamento de erros em um visualizador real ou qualquer outro tipo de aplicativo.

  2. No menu Compilar, clique em Compilar MyFirstVisualizer. O projeto deve ser compilado com êxito. Corrija os erros de compilação antes de continuar.

Adicionar o atributo necessário

Esse é o final do código do lado do depurador. Há mais uma etapa, porém: o atributo que diz ao lado a ser depurado qual coleção de classes integra o visualizador.

Para adicionar o tipo a ser visualizado para o código do lado do depuração

No código do lado do depurador, especifique o tipo a ser visualizado (a origem do objeto) para o depurador usando o atributo DebuggerVisualizerAttribute. A propriedade Target define o tipo a ser visualizado.

  1. Adicione o seguinte código do atributo a DebuggerSide.vb, depois das instruções Imports, mas antes de namespace MyFirstVisualizer:

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

  2. No menu Compilar, clique em Compilar MyFirstVisualizer. O projeto deve ser compilado com êxito. Corrija os erros de compilação antes de continuar.

Criar um agente de teste

Neste momento, o primeiro visualizador é concluído. Se você seguiu as etapas corretamente, poderá compilar o visualizador e instalá-lo no Visual Studio. Antes de instalar um visualizador no Visual Studio, no entanto, você deverá testá-lo para garantir que seja executado corretamente. Agora você criará um teste automatizado para executar o visualizador sem instalá-lo no Visual Studio.

Para adicionar um método de teste para mostrar o visualizador

  1. Adicione o método a seguir à classe public DebuggerSide.

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

  2. No menu Compilar, clique em Compilar MyFirstVisualizer. O projeto deve ser compilado com êxito. Corrija os erros de compilação antes de continuar.

    Em seguida, você deverá criar um projeto executável para chamar sua DLL do visualizador. Para simplificar, use um projeto de aplicativo de console.

Para adicionar um projeto de aplicativo de console à solução

  1. No Gerenciador de Soluções, clique com o botão direito do mouse na solução, escolha Adicionar e, em seguida, selecione Novo Projeto.

    Na caixa de pesquisa, digite visual basic, escolha Modelos, e selecione Criar um novo aplicativo de console (.NET Framework). Na caixa de diálogo que aparece, escolha Criar.

  2. Digite um nome apropriado para a biblioteca de classes, como MyTestConsole, e clique em Criar ou OK.

    Agora, você deve adicionar as referências necessárias para que MyTestConsole possa chamar MyFirstVisualizer.

Para adicionar as referências necessárias a MyTestConsole

  1. No Gerenciador de Soluções, clique com o botão direito do mouse em MyTestConsole e, no menu de atalho, clique em Adicionar Referência.

  2. Na caixa de diálogo Adicionar Referência, na guia Navegar, clique em Microsoft.VisualStudio.DebuggerVisualizers.

  3. Clique em OK.

  4. Clique com o botão direito do mouse em MyTestConsole e, em seguida, clique em Adicionar Referência novamente.

  5. Na caixa de diálogo Adicionar Referência, clique na guia Projetos e, em seguida, selecione MyFirstVisualizer.

  6. Clique em OK.

Conclua seu agente de teste e teste o visualizador

Agora, você adicionará o código para concluir um teste automatizado.

Para adicionar código a MyTestConsole

  1. No Gerenciador de Soluções, clique com o botão direito do mouse em Program.vb e, no menu de atalho, clique em Renomear.

  2. Edite o nome de Module1.vb para algo apropriado, como TestConsole.vb.

    Observe que o Visual Studio automaticamente altera a declaração de classes em TestConsole.vb para corresponder ao novo nome do arquivo.

  3. Em TestConsole. vb, adicione a seguinte declaração Imports:

    Imports MyFirstVisualizer

  4. No método Main, adicione o seguinte código:

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

    Agora, você está pronto para testar seu primeiro visualizador.

Para testar o visualizador

  1. No Gerenciador de Soluções, clique com o botão direito do mouse em MyTestConsole e, no menu de atalho, clique em Definir como Projeto de Inicialização.

  2. No menu Depurar , clique em Iniciar.

    O aplicativo de console é iniciado. O visualizador aparece e exibe a cadeia de caracteres “Hello, World”.

    Parabéns. Você acabou de criar e testar seu primeiro visualizador.

    Se você quiser usar o visualizador no Visual Studio em vez de apenas chamá-lo do teste automatizado, será preciso instalá-lo. Para obter mais informações, consulte Como instalar um visualizador.

Conteúdo relacionado