Compartilhar via

Passo a passo: Writing a Visualizer em C#

  • Artigo

Esta explicação passo a passo mostra como gravar um visualizador simples usando C#.O visualizador que você irá criar nesta explicação passo a passo exibe o conteúdo de uma seqüência usando uma caixa de mensagem do Windows forms.Este visualisador simples de cadeia de caracteres não é especialmente útil em si, mas mostra as etapas básicas que você deve seguir para criar visualisadores mais úteis para outros tipos de dados.

ObservaçãoObservação

As caixas de diálogo e comandos de menu que você vê podem diferir das descritas no Help, dependendo de suas configurações ativas ou de edição.Para alterar suas configurações, vá para o Ferramentas menu e escolha Importar e exportar configurações.Para mais informações, consulte Configurações de Visual Studio.

Código do visualisador deve ser colocado em uma DLL, que será lido pelo depurador.Portanto, a primeira etapa é criar um projeto de biblioteca de classes para a DLL.

Para criar um projeto de biblioteca de classe

  1. Sobre o arquivo menu, escolha novo e clique em Novo projeto.

  2. No Novo projeto caixa de diálogo, em Tipo de projetos, selecione Visual C#.

  3. No modelos caixa, escolha Biblioteca de classe.

  4. No nome , digite um nome apropriado para a biblioteca de classe, como MyFirstvisualisador.

  5. Clique em OK.

Após ter criado a biblioteca de classes, você deve adicionar uma referência a Debuggervisualisadors para que você possa usar classes definidas lá.Antes de adicionar a referência, no entanto, você deve renomear algumas classes para que eles tenham nomes significativos.

Renomear Class1. cs e adicionar Microsoft.VisualStudio.Debuggervisualisadors

  1. Em Solution Explorer, o botão direito do mouse Class1. cs e escolha Renomear no menu de atalho.

  2. Altere o nome de Class1. cs para algo significativo, como DebuggerSide. cs.

    ObservaçãoObservação

    Visual Studioaltera automaticamente a declaração da classe em DebuggerSide. cs para coincidir com o novo nome de arquivo.

  3. Em Solution Explorer, com o botão direito referências e escolha Adicionar referência de no menu de atalho.

  4. No Adicionar referência caixa de diálogo, no .NET guia, escolha Debuggervisualisadors.

  5. Clique em OK.

  6. Em DebuggerSide. cs, adicione a seguinte instrução para o using instruções:

    using Microsoft.VisualStudio.DebuggerVisualizers;

Agora você está pronto para criar o código do lado do depurador.Este é o código que executa no depurador para exibir as informações que você deseja visualizar.Primeiro você deve alterar a declaração do DebuggerSide objeto que herda da classe base DialogDebuggerVisualizer.

Herdar de DialogDebuggerVisualizer

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

    public class DebuggerSide

  2. Altere o código para:

    public class DebuggerSide : DialogDebuggerVisualizer

DialogDebuggerVisualizertem um método abstract (Show) que você deve substituir.

Substituir o método DialogDebuggervisualisador. show

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

    override protected void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider objectProvider)
{
}

O Show método contém o código que realmente cria a caixa de diálogo visualizador ou outra interface de usuário e exibe as informações passadas para o visualisador do depurador.Você deve adicionar código que cria a caixa de diálogo e exibe as informações.Esta explicação passo a passo, você irá fazer isso usando uma caixa de mensagem do Windows forms.Primeiro, você deve adicionar uma referência e using instrução para System.Windows.Forms.

Adicionar System.Windows.Forms

  1. Em Solution Explorer, com o botão direito referências e escolha Adicionar referência de no menu de atalho.

  2. No Adicionar referência caixa de diálogo, no .NET guia, escolha System.

  3. Clique em OK.

  4. Em DebuggerSide. cs, adicione a seguinte instrução para o using instruções:

    using System.Windows.Forms;

Agora, você adicionará alguns códigos para criar e mostrar a interface do usuário para seu visualisador.Porque este é seu primeiro visualisador, iremos manter a interface do usuário simples e usar uma caixa de mensagem.

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

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

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

  2. Sobre o Build menu, escolha Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija quaisquer erros de compilação antes de continuar.

Que é o fim do código do lado do depurador.Há mais uma etapa, no entanto; o atributo que informa o debuggee side qual coleção de classes constitui o visualisador.

Para adicionar o código do debuggee side

  1. Adicione o seguinte código de atributo para DebuggerSide. cs, após o using declarações, mas antes namespace MyFirstVisualizer:

    [assembly:System.Diagnostics.DebuggerVisualizer(
typeof(MyFirstVisualizer.DebuggerSide),
typeof(VisualizerObjectSource),
Target  = typeof(System.String),
Description  = "My First Visualizer")]

  2. Sobre o Build menu, escolha Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija quaisquer erros de compilação antes de continuar.

Neste ponto, seu primeiro visualisador é concluído.Se você tiver seguido as etapas corretamente, você pode criar o visualisador e instalá-lo em Visual Studio.Antes de instalar um visualizador em Visual Studio, no entanto, você deve testar para certificar-se de que ele seja executado corretamente.Agora você criará uma estrutura de teste para executar o visualisador sem instalá-lo em Visual Studio.

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

  1. Adicione o seguinte método à classe public DebuggerSide:

    public static void TestShowVisualizer(object objectToVisualize)
{
   VisualizerDevelopmentHost visualizerHost = new VisualizerDevelopmentHost(objectToVisualize, typeof(DebuggerSide));
   visualizerHost.ShowVisualizer();
}

  2. Sobre o Build menu, escolha Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija quaisquer erros de compilação antes de continuar.

Em seguida, você deve criar um projeto executável para chamar o visualisador DLL.Para simplificar, usaremos um projeto Console Application.

Para adicionar um projeto de aplicativo do console para a solução

  1. Sobre o arquivo menu, escolha Adicionar e clique em Novo projeto.

  2. No Adicionar novo projeto na caixa de modelos caixa, escolha Aplicativo de Console.

  3. No nome , digite um nome significativo para o aplicativo de console, como MyTestConsole.

  4. Clique em OK.

Agora, você deve adicionar que o necessário referências MyTestConsole pode chamar MyFirstvisualisador.

Para adicionar referências necessárias a MyTestConsole

  1. Em Solution Explorer, com o botão direito MyTestConsole e escolha Adicionar referência de no menu de atalho.

  2. No Adicionar referência caixa de diálogo, .NET guia, escolha Debuggervisualisadors.

  3. Clique em OK.

  4. Com o botão direito MyTestConsole e escolha Adicionar referência novamente.

  5. No Adicionar referência caixa de diálogo, clique o projetos guia e clique em MyFirstvisualisador.

  6. Clique em OK.

Agora, você adicionará código para concluir o utilitário de teste.

Para adicionar código ao MyTestConsole

  1. Em Solution Explorer, Program. cs com o botão direito e escolha Renomear no menu de atalho.

  2. Edite o nome de Program. cs para algo mais significativo, como TestConsole. cs.

    Observação   Visual Studioaltera automaticamente a declaração da classe em TestConsole. cs para coincidir com o novo nome de arquivo.

  3. Em TestConsole. cs, adicione o seguinte código para o using instruções:

    using MyFirstVisualizer;

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

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

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

Para testar o visualisador

  1. Em Solution Explorer, com o botão direito MyTestConsole e escolha Set as Startup Project no menu de atalho.

  2. Sobre o Debug menu, escolha Iniciar.

    Inicia o aplicativo de console e o Visualizador aparece e exibe a seqüência de caracteres, "Hello, World".

Parabéns.Você apenas criado e testado seu primeiro visualisador.

Se você quiser usar o visualizador em Visual Studio em vez de chamá-lo apenas de equipamento de teste, você deverá instalá-lo.Para mais informações, consulte Como: instalar um visualizador.

Usando o modelo de Item visualisador

Até agora, este passo a passo mostrou como criar um visualisador manualmente.Isso foi feito como um exercício de aprendizagem.Agora que você sabe como um visualisador simples funciona, há uma maneira fácil de criar um: usando o modelo de item visualisador.

Primeiro, você deve criar um novo projeto de biblioteca de classe.

Para criar uma nova biblioteca de classe

  1. Sobre o arquivo menu, escolha Adicionar e clique em Novo projeto.

  2. No Adicionar novo projeto caixa de diálogo, em Tipo de projetos, selecione Visual C#.

  3. No modelos caixa, escolha Biblioteca de classe.

  4. No nome , digite um nome apropriado para a biblioteca de classe, como MySecondvisualisador.

  5. Clique em OK.

Agora, você pode adicionar um item visualisador a ela:

Para adicionar um item visualisador

  1. Em Solution Explorer, clique com o botão direito MySecondvisualisador.

  2. No menu de atalho, escolha Add e clique em Novo Item.

  3. No Adicionar Novo Item caixa de diálogo, em modelos de, Visual Studio Installed Templates, selecione Debugger Visualizer.

  4. No nome , digite um nome apropriado, como Secondvisualisador.

  5. Clique em Adicionar.

É tudo que há nele.Examine o arquivo Secondvisualisador. cs e exibir o código do modelo adicionado para você.Vá em frente e experimentar o código.Agora que você sabe o básico, você está em seu caminho para criar mais complexos e úteis visualisadores de sua preferência.

Consulte também

Tarefas

Como: instalar um visualizador

Conceitos

Arquitetura de Visualizador

Outros recursos

Visualizadores