Como rastreamento e depuração no Visual C++ .NET e no Visual C++ 2005

IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.

Clique aqui para ver a versão em Inglês deste artigo: 815787
Para uma versão deste artigo do Microsoft Visual Basic. NET, consulte 313417.
Para obter uma Microsoft Visual translation from VPE for Csharp .NET versão deste artigo, consulte 815788.

Este artigo se refere ao seguinte namespace Microsoft .NET Framework Class Library:
  • System::Diagnostics

NESTA TAREFA

Sumário
Este artigo descreve como usar a classe Debug e a classe de rastreamento . Essas classes estão disponíveis no Microsoft .NET Framework. Você pode usar essas classes para fornecer informações sobre o desempenho de um aplicativo durante o desenvolvimento de aplicativo, ou após a implantação para produção. Essas classes são apenas uma parte dos recursos de instrumentação que estão disponíveis no .NET Framework.

Back to the top

Requisitos

A lista a seguir descreve o hardware recomendado, software, infra-estrutura de rede e service packs que você precisa:
  • Microsoft Windows 2000, Microsoft Windows XP ou Microsoft Windows Server 2003
  • Microsoft Visual C++ .NET ou Microsoft Visual C++ 2005
Este artigo também presume que você esteja familiarizado com a depuração do aplicativo.

Back to the top

Descrição da técnica usando a classe de depuração

As etapas de "Create a Sample That Uses the Debug Class" seção deste artigo demonstram como criar um aplicativo de console que usa a classe Debug para fornecer informações sobre um aplicativo durante o tempo de execução.

Enquanto um aplicativo é executado, você pode usar métodos da classe Debug para exibir mensagens que o ajudam a controlar o aplicativo durante o tempo de execução, para detectar erros, ou para fornecer informações de medição de desempenho. Por padrão, as mensagens que exibe a classe Debug aparecem na janela de saída no Visual Studio .NET.

O código de exemplo neste artigo usa o método WriteLine para exibir uma mensagem, seguida de um terminador de linha. Quando você usar esse método para exibir uma mensagem, cada mensagem é exibida em uma linha separada na janela Output.

Quando você usa o método Assert da classe Debug , na janela Output exibe uma mensagem somente se uma condição especificada for avaliada como false . A mensagem também é exibida ao usuário em uma caixa de diálogo modal. Esta caixa de diálogo inclui a mensagem, o nome do projeto e o número de instrução Debug::Assert . A caixa de diálogo também inclui três botões a seguir:
  • Anular : pára a aplicativo executando.
  • Repetir : O aplicativo entra no modo de depuração.
  • Ignorar : O aplicativo continua.
Você deve clicar um desses botões em que o aplicativo possa continuar.

Você também pode direcionar a saída da classe Debug para destinos diferente na janela Output. A classe Debug contém uma coleção que é chamada de ouvintes que inclui objetos de escuta .

Cada objeto de escuta na coleção Listeners recebe saída da classe Debug e, em seguida, direciona essa saída para um destino especificado.

Use a classe TextWriterTraceListener para definir objetos de escuta . Você pode especificar o destino de uma classe TextWriterTraceListener usando um construtor apropriado.

Alguns destinos de saída possíveis incluem o seguinte:
  • A janela de console usando a propriedade System::Console::Out .
  • Um arquivo de texto (.txt) usando a instrução System::IO::File::CreateText("FileName.txt") .
Depois de criar um objeto TextWriterTraceListener , você deve adicionar o objeto à coleção Debug::Listeners para receber saída de uma classe de depuração .

Back to the top

Criar um exemplo que usa a classe de depuração

  1. Inicie o Microsoft Visual Studio .NET ou Microsoft Visual Studio 2005.
  2. No menu arquivo , aponte para novo e, em seguida, clique em Project .
  3. No Visual C++ .NET 2002, clique em Projetos do Visual c++ em Tipos de projeto e, em seguida, clique em Aplicativo de C++ gerenciado em modelos .

    No Visual C++ .NET 2003, clique em Projetos do Visual c++ em Tipos de projeto e, em seguida, clique em Aplicativo de console (NET) em modelos .

    Observação No Visual Studio 2005, clique em Visual C++ em Tipos de projeto .
  4. Na caixa de texto nome , digite ConInfo e, em seguida, clique em OK .
  5. No Solution Explorer, clique duas vezes em ConInfo.cpp para exibir a janela de código.
  6. No arquivo ConInfo.cpp, adicione as seguintes instruções antes do método _tmain :
    #using <System.Xml.Dll>using namespace System::Diagnostics;
    se você estiver usando o Visual C++ .NET 2002, adicione o seguinte código adicional na janela de código antes das diretivas usando :
    #using <System.Dll>	#include <tchar.h>
  7. Para inicializar variáveis para armazenar informações sobre um produto, adicione as seguintes instruções de declaração para o método _tmain :
    String * sProdName = S"Widget";int iUnitQty = 100;double  dUnitCost = 1.03;
  8. Você pode usar diferentes métodos de classe Debug para exibir mensagens que controlar a execução de um aplicativo da seguinte maneira:
    • Especificar a mensagem para exibir como o primeiro parâmetro de entrada do método WriteLine do de class. Debug
      Debug::WriteLine(S"Debug Information-Product Starting ");
    • Para facilitar a leitura, use o método recuo da classe Debug para recuar mensagens subseqüentes na janela de saída da seguinte maneira:
      Debug::Indent();
    • Para exibir o conteúdo de variáveis selecionadas, use o método WriteLine da classe Debug da seguinte maneira:
      Debug::WriteLine(String::Concat(S"The product name is ", sProdName));Debug::WriteLine(String::Concat(S"The available units on hand are ", iUnitQty.ToString()));Debug::WriteLine(String::Concat(S"The per unit cost is ", dUnitCost.ToString()));
      Note The Concat method of the String class concatenates two strings.
    • Você também pode usar o método WriteLine da classe Debug para exibir o espaço para nome e o nome de classe para um objeto. Por exemplo, o código a seguir exibe o espaço para nome System::Xml::XmlDocument na janela Output:
      System::Xml::XmlDocument * oxml = new System::Xml::XmlDocument();Debug::WriteLine(oxml);
    • Para formatar a saída, você pode incluir um parâmetro de categoria como um opcional, segunda entrada do método WriteLine da classe Debug . Se você especificar uma categoria, o formato da mensagem em janela saída é da seguinte maneira:
      categoria: mensagem
      Por exemplo, a primeira linha de código a seguir exibe o seguinte
      Campo: O nome do produto é widget
      na saída janela:
      Debug::WriteLine(String::Concat(S"The product name is " , sProdName), S"Field");Debug::WriteLine(String::Concat(S"The units on hand are ",iUnitQty.ToString()) ,S"Field");Debug::WriteLine(String::Concat(S"The per unit cost is ", dUnitCost.ToString()) ,S"Field");Debug::WriteLine(String::Concat(S"Total Cost is  ", (iUnitQty * dUnitCost).ToString()),S"Calc");
    • Quando você usar o método WriteLineIf da classe Debug , na janela Output exibe mensagens somente se uma condição designada for avaliada como true . O primeiro parâmetro de entrada do método WriteLineIf é a condição que é avaliada. O segundo parâmetro do método WriteLineIf é a mensagem que aparece somente se a condição no primeiro parâmetro for avaliada como true .
      Debug::WriteLineIf(iUnitQty > 50, S"This message WILL appear");Debug::WriteLineIf(iUnitQty < 50, S"This message will NOT appear");
    • Use o método Assert da classe Debug para que a janela de saída exibe uma mensagem somente se uma condição especificada for avaliada como false .
      Debug::Assert(dUnitCost > 1, S"Message will NOT appear");Debug::Assert(dUnitCost < 1, S"Message will appear since dUnitcost  < 1 is false");
    • Criar objetos TextWriterTraceListener para a janela de console (tr1) e para um texto de arquivo que é nomeado Output.txt (tr2) e, em seguida, adicionar os dois objetos à coleção Debug::Listeners .
      TextWriterTraceListener * tr1 = new TextWriterTraceListener(System::Console::Out);Debug::Listeners->Add(tr1);TextWriterTraceListener * tr2 = new TextWriterTraceListener(System::IO::File::CreateText(S"Output.txt"));Debug::Listeners->Add(tr2);
    • Para facilitar a leitura, use o método Unindent da classe Debug para remover o recuo para mensagens subseqüentes que gera a classe Debug . Quando você usa o método de recuo e o método Unindent juntos, um leitor pode distinguir a saída como um grupo.
      Debug::Unindent();Debug::WriteLine(S"Debug Information-Product Ending");
    • Para certificar-se que cada objeto de escuta recebe todas as sua saída, chame o método Flush para depuração classe buffers.
      Debug::Flush();
    Adicione os métodos adequados ao seu código e em seguida, pressione CTRL + SHIFT + B para criar o aplicativo.
Back to the top

Usar o rastreamento de classe

Você também pode usar a classe de rastreamento para exibir mensagens que controlam a execução de um aplicativo. A classe de rastreamento e a classe Debug contêm métodos similares para exibir a saída. Esses métodos incluem o seguinte:
  • WriteLine
  • WriteLineIf
  • Recuar
  • Retirar recuo
  • declarar
  • liberar
Você pode usar a classe de rastreamento e a classe Debug separadamente ou juntas no mesmo aplicativo. Em um projeto Debug Solution Configuration, tanto saída de rastreamento e Depurar saída estão ativas. O projeto gera saída de ambas essas classes para todos os objetos de escuta . No entanto, um projeto Release Solution Configuration apenas gera saída de uma classe de rastreamento . O projeto Release Solution Configuration ignora quaisquer chamadas de método de classe Debug .
Trace::WriteLine(String::Concat(S"The product name is ",sProdName));Trace::WriteLine(String::Concat(S"The product name is ",sProdName), S"Field" );Trace::WriteLineIf(iUnitQty > 50, S"This message WILL appear");Trace::Assert(dUnitCost > 1, S"Message will NOT appear");Trace::Unindent();Trace::WriteLine(S"Trace Information-Product Ending");Trace::Flush();Console::ReadLine();
Back to the top

Concluir a listagem de código

#include "stdafx.h"#using <mscorlib.dll>//Uncomment following line for Microsoft Visual C++ .NET 2002//#using <System.Dll>#using <System.Xml.Dll>//Uncomment following line for Microsoft Visual C++ .NET 2002//#include <tchar.h>using namespace System;using namespace System::Diagnostics;// This is the entry point for this applicationint _tmain(void){    String * sProdName = S"Widget";    int iUnitQty = 100;    double  dUnitCost = 1.03;    Debug::WriteLine(S"Debug Information-Product Starting ");    Debug::Indent();    Debug::WriteLine(String::Concat(S"The product name is ", sProdName));    Debug::WriteLine(String::Concat(S"The available units on hand are ", iUnitQty.ToString()));    Debug::WriteLine(String::Concat(S"The per unit cost is ", dUnitCost.ToString()));    System::Xml::XmlDocument * oxml = new System::Xml::XmlDocument();    Debug::WriteLine(oxml);    Debug::WriteLine(String::Concat(S"The product name is " , sProdName), S"Field");    Debug::WriteLine(String::Concat(S"The units on hand are ",iUnitQty.ToString()) ,S"Field");    Debug::WriteLine(String::Concat(S"The per unit cost is ", dUnitCost.ToString()) ,S"Field");    Debug::WriteLine(String::Concat(S"Total Cost is  ", (iUnitQty * dUnitCost).ToString()),S"Calc");    Debug::WriteLineIf(iUnitQty > 50, S"This message WILL appear");    Debug::WriteLineIf(iUnitQty < 50, S"This message will NOT appear");    Debug::Assert(dUnitCost > 1, S"Message will NOT appear");    Debug::Assert(dUnitCost < 1, S"Message will appear since dUnitcost  < 1 is false");    TextWriterTraceListener * tr1 = new TextWriterTraceListener(System::Console::Out);    Debug::Listeners->Add(tr1);    TextWriterTraceListener * tr2 = new TextWriterTraceListener(System::IO::File::CreateText(S"Output.txt"));    Debug::Listeners->Add(tr2);    Debug::WriteLine(String::Concat(S"The product name is ",sProdName));    Debug::WriteLine(String::Concat(S"The available units on hand are ",iUnitQty.ToString()));    Debug::WriteLine(String::Concat(S"The per unit cost is ", dUnitCost.ToString()));    Debug::Unindent();    Debug::WriteLine(S"Debug Information-Product Ending");    Debug::Flush();    Trace::WriteLine(S"Trace Information-Product Starting ");    Trace::Indent();    Trace::WriteLine(String::Concat(S"The product name is ",sProdName));    Trace::WriteLine(String::Concat(S"The product name is ",sProdName), S"Field" );    Trace::WriteLineIf(iUnitQty > 50, S"This message WILL appear");    Trace::Assert(dUnitCost > 1, S"Message will NOT appear");    Trace::Unindent();    Trace::WriteLine(S"Trace Information-Product Ending");    Trace::Flush();    Console::ReadLine();    return 0;}
Observação Você deve adicionar a opção de compilador de suporte de tempo de execução idioma comum (/ CLR: oldSyntax) no Visual C++ 2005 a compilar com êxito o exemplo de código anterior. Para adicionar a opção de compilador de suporte de tempo de execução idioma comum no Visual C++ 2005, siga estas etapas:
  1. Clique em Project e clique em <ProjectName> propriedades .

    Observação <ProjectName> é um espaço reservado para o nome do projeto.
  2. Expanda Configuration Properties e, em seguida, clique em Geral .
  3. Clique para selecionar Common Language Runtime suporte, sintaxe antiga (/ CLR: oldSyntax) no projeto oferece suporte a Common Language Runtime configuração no painel à direita, clique em Aplicar e em seguida, clique em OK .
Para obter mais informações sobre o common language runtime oferece suporte à opção do compilador, visite o seguinte site da Microsoft:
/ clr (Common Language Runtime Compilation)
http://msdn2.microsoft.com/en-us/library/k8d11d4s.aspx
Back to the top

Verifique se seu aplicativo funciona

  1. Verifique se seu projeto usa a solução Debug Configuration. Para fazer isso, execute as seguintes etapas:
    1. No menu Build , clique em Gerenciador de configuração .
    2. Clique em Debug na lista Active Solution Configuration e, em seguida, clique em Fechar .
  2. Pressione CTRL + ALT + O, para exibir a janela de saída.
  3. Pressione F5 para iniciar o aplicativo no modo de depuração.
  4. Quando a caixa de diálogo Assertion Failed for exibida, clique em Ignorar .
  5. Na janela do console, pressione ENTER. O aplicativo é encerrado, e a janela de saída exibe a seguinte saída:
    Debug Information-Product Starting     The product name is Widget    The available units on hand are 100    The per unit cost is 1.03    System.Xml.XmlDocument    Field: The product name is Widget    Field: The units on hand are 100    Field: The per unit cost is 1.03    Calc: Total Cost is  103    This message WILL appear    ---- DEBUG ASSERTION FAILED -------- Assert Short Message ----Message will appear since dUnitcost  < 1 is false---- Assert Long Message ----    The product name is Widget    The available units on hand are 100    The per unit cost is 1.03Debug Information-Product EndingTrace Information-Product Starting     The product name is Widget    Field: The product name is Widget    This message WILL appearTrace Information-Product Ending
    Além disso, o arquivo output.txt deve conter a seguinte saída:
        The product name is Widget    The available units on hand are 100    The per unit cost is 1.03Debug Information-Product EndingTrace Information-Product Starting     The product name is Widget    Field: The product name is Widget    This message WILL appearTrace Information-Product Ending

    Observação Você observar essa saída ao usar o código que é fornecido na seção "Complete Code Listing" deste artigo. O arquivo output.txt está localizado na mesma pasta que os arquivos de origem do projeto. Por padrão, os arquivos de origem do projeto são armazenados no diretório C:\Documents and Settings\ UserName \Meus Documentos\Visual Studio Projects\ConInfo\.
Back to the top

Solução de problemas

  • Se o tipo de configuração de solução é definido como Release , a saída de classe Debug será ignorada.
  • Depois de criar um objeto TextWriterTraceListener para um destino específico, o objeto TextWriterTraceListener recebe saída da classe de rastreamento e da classe Debug . Esse comportamento ocorre independentemente de você usar o método Add da classe Trace ou o método Add da classe Debug para adicionar o objeto TextWriterTraceListener à coleção Listeners .
  • Se você adicionar um objeto de escuta para o mesmo destino na classe de rastreamento e na classe Debug , cada linha de saída aparecerá duas vezes, independentemente se a classe Debug ou a classe Trace gera a saída.
    TextWriterTraceListener * mywriter = new TextWriterTraceListener(System::Console::Out);Debug::Listeners->Add(mywriter);TextWriterTraceListener * myCreator = new TextWriterTraceListener(System::Console::Out);Debug::Listeners->Add(myCreator);
Back to the top
Referências
Para obter mais informações sobre a classe de rastreamento , visite o seguinte site da Microsoft Developer Network (MSDN):Para obter mais informações sobre a classe Debug , visite o seguinte site da MSDN:

Back to the top
Aplicativo de console, classe de depuração, classe de rastreamento, WriteLine, Assert, recuo, retirar recuo da, escuta

Aviso: este artigo foi traduzido automaticamente

Propriedades

ID do Artigo: 815787 - Última Revisão: 06/01/2007 01:53:55 - Revisão: 2.4

Microsoft Visual C++ 2005 Express Edition, Microsoft Visual C++ .NET 2003 Standard Edition, Microsoft Visual C++ .NET 2002 Standard Edition, Microsoft .NET Framework 1.1, Microsoft .NET Framework 1.0

  • kbmt kbprogramming kbdebug kbconsole kbxml kbwindbg kbhowtomaster KB815787 KbMtpt
Comentários