Compartilhar via

Usar classes de rastreamento e depuração no Visual Basic .NET

Este artigo fornece informações sobre como usar as Debug classes e no Trace Visual Basic .NET.

Versão original do produto: Visual Basic .NET
Número original do KB: 313417

Resumo

Este artigo demonstra como usar as Debug classes e .Trace 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 do aplicativo ou após a implantação na produção. Essas classes são apenas uma parte dos recursos de instrumentação disponíveis no .NET Framework.

Requisitos

A lista a seguir descreve o hardware, o software, a infraestrutura de rede e os service packs recomendados de que você precisa:

  • Windows
  • Visual Basic .NET

Este artigo também pressupõe que você esteja familiarizado com a depuração do programa.

Descrição da técnica

As etapas na seção Criar um exemplo com a classe Depurar demonstram como criar um aplicativo de console que usa a Debug classe para fornecer informações sobre a execução do programa.

Quando o programa é executado, você pode usar métodos da classe para produzir mensagens que ajudam a monitorar, detectar falhas ou fornecer informações de medição de Debug desempenho. Por padrão, as mensagens que a Debug classe produz aparecem na janela Saída do IDE (Ambiente de Desenvolvimento Integrado) do Microsoft Visual Studio.

O código de exemplo usa o WriteLine método para produzir uma mensagem que é seguida por um terminador de linha. Quando você usa esse método para produzir uma mensagem, cada mensagem aparece em uma linha separada na janela Saída.

Se você usar o Assert Debug método da classe, a janela Saída exibirá uma mensagem somente se uma condição especificada for avaliada como falsa. A mensagem também aparece em uma caixa de diálogo modal para o usuário. A caixa de diálogo inclui a mensagem, o nome do projeto e o número da Debug.Assert instrução. A caixa de diálogo também inclui três botões de comando:

  • Anular: o aplicativo para de ser executado.
  • Repetir: o aplicativo entra no modo de depuração.
  • Ignorar: o aplicativo continua. O usuário deve clicar em um desses botões antes que o aplicativo possa continuar.

Você também pode direcionar a Debug saída da classe para destinos diferentes da janela Saída. A Debug classe tem uma coleção chamada Listeners que inclui objetos Listener. Cada objeto Listener monitora a Debug saída e direciona a saída para um destino especificado. Cada Listener na Listeners coleção recebe qualquer saída gerada pela Debug classe. Use a TextWriterTraceListener classe para definir objetos Listener. Você pode especificar o destino de uma TextWriterTraceListener classe por meio de seu construtor. Alguns alvos de saída possíveis incluem:

  • A janela Console usando a System.Console.Out propriedade.
  • Um arquivo de texto usando a System.IO.File.CreateText("FileName.txt")) instrução.

Depois de criar um TextWriterTraceListener objeto, você deve adicionar o objeto à coleção para receber Debug a Debug.Listeners saída.

Criar um exemplo com a classe Debug

  1. Use o Visual Basic .NET para criar um novo projeto de Aplicativo de Console chamado conInfo. Um módulo público chamado Module1 é adicionado ao projeto por padrão.

  2. Para inicializar variáveis para conter informações sobre um produto, adicione as seguintes Dim instruções:

    Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 1.03

  3. Especifique a mensagem que a classe produz como o primeiro parâmetro de entrada do WriteLine método. Pressione a combinação de teclas CTRL+ALT+O para garantir que a janela Saída esteja visível.

    Debug.WriteLine("Debug Information-Product Starting ")

  4. Para facilitar a leitura, use o método para recuar Indent mensagens subsequentes na janela Saída:

    Debug.Indent()

  5. Para exibir o conteúdo das variáveis selecionadas, use o método da WriteLine seguinte maneira:

    Debug.WriteLine("The product name is " & sProdName)
Debug.WriteLine("The available units on hand are " & iUnitQty)
Debug.WriteLine("The per unit cost is " & dUnitCost)

  6. Você também pode usar o WriteLine método para exibir o namespace e o nome da classe para um objeto existente. Por exemplo, o código a seguir exibe o System.Xml.XmlDocument namespace na janela Saída:

    Dim oxml As New System.Xml.XmlDocument()
Debug.WriteLine(oxml)

  7. Para organizar a saída, você pode incluir uma categoria como um segundo parâmetro de entrada opcional do WriteLine método. Se você especificar uma categoria, o formato da mensagem da janela Saída será "categoria: mensagem". Por exemplo, a primeira linha do código a seguir exibe "Campo: O nome do produto é Widget" na janela Saída:

    Debug.WriteLine("The product name is " & sProdName, "Field")
Debug.WriteLine("The units on hand are " & iUnitQty, "Field")
Debug.WriteLine("The per unit cost is " & dUnitCost, "Field")
Debug.WriteLine("Total Cost is" & iUnitQty * dUnitCost, "Calc")

  8. A janela Saída só poderá exibir mensagens se uma condição designada for avaliada como verdadeira usando o WriteLineIf Debug método da classe. A condição a ser avaliada é o primeiro parâmetro de entrada do WriteLineIf método. O segundo parâmetro de WriteLineIf é a mensagem que aparece somente se a condição no primeiro parâmetro for avaliada como verdadeira.

    Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")

  9. Use o método Assert da classe para que a janela Saída exiba a mensagem somente se uma condição especificada for avaliada Debug como falsa:

    Debug.Assert(dUnitCost > 1, "Message will NOT appear")
Debug.Assert(dUnitCost < 1, "Message will appear")

  10. Crie os TextWriterTraceListener objetos para a janela Console (tr1) e para um arquivo de texto chamado Output.txt (tr2) e adicione cada objeto à Debug Listeners coleção:

    Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)

Dim tr2 As New _
    TextWriterTraceListener(System.IO.File.CreateText("Output.txt"))
Debug.Listeners.Add(tr2)

  11. Para facilitar a leitura, use o Unindent método para remover o recuo das mensagens subsequentes geradas pela Debug classe. Quando você usa os Indent métodos e os Unindent métodos juntos, o leitor pode distinguir a saída como grupo.

    Debug.Unindent()
Debug.WriteLine("Debug Information-Product Ending")

  12. Para garantir que cada objeto Listener receba toda a sua saída, chame o Flush método para os Debug buffers de classe:

    Debug.Flush()

Usando a classe Trace

Você também pode usar a Trace classe para produzir mensagens que monitoram a execução de um aplicativo. As Trace classes and Debug compartilham a maioria dos mesmos métodos para produzir saída, incluindo:

  • WriteLine
  • WriteLineIf
  • Indent
  • Unindent
  • Assert
  • Flush

Você pode usar as Trace classes e separadamente Debug ou em conjunto no mesmo aplicativo. Em um projeto de Configuração de Solução de Depuração, a saída e a Trace Debug saída estão ativas. O projeto gera saída de ambas as classes para todos os objetos Listener. No entanto, um projeto de Configuração de Solução de Versão gera apenas a saída de uma Trace classe. O projeto de Configuração da Solução de Versão ignora todas as Debug invocações de método de classe.

Trace.WriteLine("Trace Information-Product Starting ")
Trace.Indent()

Trace.WriteLine("The product name is " & sProdName)
Trace.WriteLine("The product name is " & sProdName, "Field")
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Trace.Assert(dUnitCost > 1, "Message will NOT appear")

Trace.Unindent()
Trace.WriteLine("Trace Information-Product Ending")
Trace.Flush()
Console.ReadLine()

Verifique se funciona

  1. Verifique se Depurar é a configuração atual da solução.

  2. Se a janela do Gerenciador de Soluções não estiver visível, pressione a combinação de teclas CTRL+ALT+L para exibir essa janela.

  3. Clique com o botão direito do mouse em conInfo e clique em Propriedades.

  4. No painel esquerdo da página de propriedades conInfo , na pasta Configuração , verifique se a seta aponta para Depuração.

  5. Acima da pasta Configuração , na caixa de listagem suspensa Configuração, clique em Ativo (Depurar) ou Depurar e clique em OK.

  6. Pressione CTRL+ALT+O para exibir a janela Saída.

  7. Pressione a tecla F5 para executar o código. Quando a caixa de diálogo Falha na Asserção for exibida, clique em Ignorar.

  8. Na janela Console, pressione ENTER. O programa deve terminar e a janela Saída deve exibir 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
---- Assert Long Message ----

at Module1.Main() C:\Documents and Settings\Administrator\My
Documents\Visual Studio Projects\conInfo\Module1.vb(29)

    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
    The product name is Widget
    Field: The product name is Widget
    This message WILL appear
Trace Information-Product Ending

  9. A janela Console e o arquivo Output.txt devem exibir a seguinte saída:

    (The Output.txt file is located in the same directory as the conInfo
executable, conInfo.exe. Normally this is the \bin folder of where the
project source has been stored. By default that would be C:\Documents and
Settings\User login\My Documents\Visual Studio Projects\conInfo\bin)
    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
    The product name is Widget
    Field: The product name is Widget
    This message WILL appear
Trace Information-Product Ending

Listagem de código completo

Module Module1
    Sub Main()
        Dim sProdName As String = "Widget"
        Dim iUnitQty As Integer = 100
        Dim dUnitCost As Decimal = 1.03

        Debug.WriteLine("Debug Information-Product Starting ")
        Debug.Indent()

        Debug.WriteLine("The product name is " & sProdName)
        Debug.WriteLine("The available units on hand are " & iUnitQty)
        Debug.WriteLine("The per unit cost is " & dUnitCost)

        Dim oxml As New System.Xml.XmlDocument()
        Debug.WriteLine(oxml)

        Debug.WriteLine("The product name is " & sProdName, "Field")
        Debug.WriteLine("The units on hand are " & iUnitQty, "Field")
        Debug.WriteLine("The per unit cost is " & dUnitCost, "Field")
        Debug.WriteLine("Total cost is " & iUnitQty * dUnitCost, "Calc")

        Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
        Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")

        Debug.Assert(dUnitCost > 1, "Message will NOT appear")
        Debug.Assert(dUnitCost < 1, "Message will appear")

        Dim tr1 As New TextWriter`Trace`Listener(System.Console.Out)
        Debug.Listeners.Add(tr1)

        Dim tr2 As New _
            TextWriterTraceListener(System.IO.File.CreateText("Output.txt"))

        Debug.Listeners.Add(tr2)

        Debug.WriteLine("The product name is " & sProdName)
        Debug.WriteLine("The available units on hand are " & iUnitQty)
        Debug.WriteLine("The per unit cost is " & dUnitCost)

        Debug.Unindent()
        Debug.WriteLine("Debug Information-Product Ending")

        Debug.Flush()

        Trace.WriteLine("`Trace` Information-Product Starting ")

        Trace.Indent()

        Trace.WriteLine("The product name is " & sProdName)
        Trace.WriteLine("The product name is " & sProdName, "Field")
        Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear")
        Trace.Assert(dUnitCost > 1, "Message will NOT appear")

        Trace.Unindent()
        Trace.WriteLine("Trace Information-Product Ending")

        Trace.Flush()

        Console.ReadLine()
    End Sub
End Module

Solução de problemas

  • Se o tipo de configuração da solução for Release, a saída da Debug classe será ignorada.

  • Depois de criar uma TextWriterTraceListener classe para um destino específico, TextWriterTraceListener o recebe a saída do e das Trace Debug classes. Isso ocorre independentemente de você usar o Add Trace método da ou a Debug classe para adicionar TextWriterTraceListener à Listeners classe.

  • Se você adicionar um objeto Listener para o mesmo destino nas Trace classes e , Debug cada linha de saída será duplicada, independentemente de Debug ou Trace gerar a saída.

    Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)

Referências

  • Last updated on