Compartilhar via

Demonstra Passo a passo: Escrever um visualizador em translation from VPE for Csharp

  • Artigo

Este tópico se aplica a:

Edição

Visual Basic

C#

C++

Desenvolvedores Web

Express

Padrão

PRO e equipe

Legenda de tabela:

Aplica-se

Não é aplicada

Comando ou comandos oculta por padrão.

Esta explicação passo a passo mostra como gravar um visualizador simples usando translation from VPE for Csharp.O visualizador que você irá criar nessa explicação passo a passo exibe o conteúdo de uma sequência usando uma caixa de mensagem de formulários de Windows.Este visualizador simples de cadeia de caracteres não é especialmente útil em si, mas ele mostra as etapas básicas que devem ser seguidas para criar visualisadores mais úteis para outros tipos de dados.

Observaçã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 as configurações, vá para o Ferramentas menu e escolher Importar e exportar configurações.Para obter mais informações, consulte Configurações do Visual Studio.

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

Para criar um projeto de biblioteca de classes

  1. Sobre o Arquivo menu, escolher Novo e, em seguida, clicar Novo projeto.

  2. Na caixa de diálogo New Project, em Project Types, selecione Visual C#.

  3. Na caixa Templates, escolha Class Library.

  4. No Nome, digite um nome apropriado para o classe biblioteca, sistema autônomo MyFirstvisualisador.

  5. Clique em OK.

Depois de criar a biblioteca de classes, você deve adicionar uma referência ao Microsoft.VisualStudio.Debuggervisualisadors.dll, para que você possa usar classes definidas lá.Antes de adicionar a referência, no entanto, você deve renomear algumas classes para que tenham nomes significativos.

Renomear Class1.cs e adicionar Microsoft.VisualStudio.Debuggervisualisadors

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no Class1.cs e escolher Renomear no menu de atalho.

  2. alterar o nome de Class1.cs para algo significativo, sistema autônomo DebuggerSide.cs.

    Observação:

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

  3. In O gerenciador de soluções, clicar com o botão direito do mouse em Referências e escolherAdicionar referência no menu de atalho.

  4. Na caixa de diálogo Add Reference, na guia .NET, escolha Microsoft.VisualStudio.Debuggervisualisadors.DLL.

  5. Clique em OK.

  6. Em DebuggerSide.cs, adicione a seguinte demonstrativo à using instruções:

    using Microsoft.VisualStudio.DebuggerVisualizers;

Agora você está pronto para criar o código do lado do depurador.Isso é o código que executa com o depurador para exibir as informações que você deseja visualizar.Primeiro, é necessário alterar a declaração do DebuggerSide objeto para que herde da classe base DialogDebuggerVisualizer.

Herdar de DialogDebuggerVisualizer

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

    public class DebuggerSide

  2. Altere o código para:

    public class DebuggerSide : DialogDebuggerVisualizer

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

Para substituir o método DialogDebuggervisualisador.show

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

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

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

Adicionar sistema.Windows.Forms

  1. In O gerenciador de soluções, clicar com o botão direito do mouse em Referências e escolherAdicionar referência no menu de atalho.

  2. Na caixa de diálogo Add Reference, na guia .NET, escolha System.Windows.Forms.DLL.

  3. Clique em OK.

  4. Em DebuggerSide.cs, adicione a seguinte demonstrativo à 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.Como esse é o primeiro visualisador, nós vamos 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 erro tratamento.Você deve incluir o tratamento de erro em um visualizador real ou qualquer Outros tipo de aplicativo.

  2. Sobre o Compilação menu, escolher Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija qualquer erro de compilação antes de continuar

Que é o participante do código do lado do depurador.No entanto, há uma etapa a mais: o atributo que informa o debuggee side qual coleção de classes constitui o visualizador.

Para adicionar o código do debuggee side

  1. Adicione o seguinte código de atributo para DebuggerSide.cs, após o using instruçõ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 Compilação menu, escolher Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija qualquer erro de compilação antes de continuar.

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

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

  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 Compilação menu, escolher Build MyFirstVisualizer.O projeto deve compilar com êxito.Corrija qualquer erro 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 de aplicativos do console.

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

  1. Sobre o Arquivo menu, escolher Adicionar e, em seguida, clicar Novo projeto.

  2. No Adicionar novo projeto caixa de diálogo, no Modelos caixa, escolher Aplicativo de console.

  3. No Nome , digite um nome significativo para o aplicativo de console, sistema autônomo MyTestConsole.

  4. Clique em OK.

Agora, você deve adicionar as referências necessárias para MyTestConsole poder chamar MyFirstvisualisador.

Para adicionar referências necessárias a MyTestConsole

  1. In O gerenciador de soluções, clicar com o botão direito do mouse em MyTestConsole e escolherAdicionar referência no menu de atalho.

  2. Na caixa de diálogo Add Reference, guia .NET, escolha Microsoft.VisualStudio.Debuggervisualisadors.DLL.

  3. Clique em OK.

  4. clicar com o botão direito do mouse em MyTestConsole e escolherAdicionar referência novamente.

  5. No Adicionar referência diálogo, clicar no Projetos guia e clicar MyFirstvisualisador.

  6. Clique em OK.

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

Para adicionar código a MyTestConsole

  1. In O gerenciador de soluções, clicar com o botão direito do mouse no programa.cs e escolher Renomear no menu de atalho.

  2. Edite o nome de programa.cs para algo mais significativo, sistema autônomo TestConsole.cs.

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

  3. Em TestConsole.cs, adicione o seguinte código à 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 visualizador

  1. In O gerenciador de soluções, clicar com o botão direito do mouse em MyTestConsole e escolherconjunto sistema autônomo projeto de inicialização no menu de atalho.

  2. No menu Debug, escolha Start.

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

Parabéns.Você acaba de ter criado e testado seu primeiro visualisador.

Se você deseja usar seu visualizador no Visual Studio em vez de simplesmente chamá-lo do agente de teste, você precisará instalá-lo. Para obter mais informações, consulte Como: Instalar um visualizador.

Usando o modelo do item visualisador

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

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

Para criar uma nova biblioteca de classes

  1. Sobre o Arquivo menu, escolher Adicionar e, em seguida, clicar Novo projeto.

  2. Na caixa de diálogo Add New Project, em Project Types, selecione Visual C#.

  3. Na caixa Templates, escolha Class Library.

  4. No Nome, digite um nome apropriado para a biblioteca de classes, sistema autônomo MySecondvisualisador.

  5. Clique em OK.

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

Para adicionar um item visualizador

  1. In O gerenciador de soluções, clicar com o botão direito do mouse MySecondvisualisador.

  2. No menu de atalho, escolher Adicionar e, em seguida, clicar Novo item.

  3. Na caixa de diálogo Add New Item em Templates, Visual Studio Installed Templates, selecione Debugger Visualizer.

  4. No Nome, digite um nome apropriado, sistema autônomo Secondvisualisador.cs.

  5. Clique em Adicionar.

Que é tudo há para ele.Examine o arquivo Secondvisualisador.cs e exiba o código que o modelo adicionou para você.Vá em frente e faça experiências com o código.Agora que você sabe os fundamentos básicos, 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