Gravando na janela de saída do Visual Studio

Estou tentando escrever uma mensagem na janela de saída para fins de depuração. Eu procurei por uma função como a de Java system.out.println(""). Eu tentei Debug.Write, Console.Writee Trace.Write. Não apresenta um erro, mas também não imprime nada.

As opções "Definir constante DEBUG" e "Definir constante TRACE" estão marcadas.

Ferramentas do menu → Opções → Depuração → A opção "Redirecionar todo o texto da janela de saída para a janela imediata" não está marcada.

Configuração: Ativo (Depuração)

Nota: Criei um projeto com o assistente como "Aplicativo Windows Forms", se relevante. Não faço ideia para onde procurar.

Adicione o System.Diagnosticsespaço para nome e, em seguida, você pode usar Debug.WriteLine()para imprimir rapidamente uma mensagem na janela de saída do IDE. Para mais detalhes, consulte estes:

• Como rastrear e depurar no Visual C #
• Um tratado sobre o uso de classes Debug e Trace, incluindo tratamento de exceções

Isso gravará na janela de saída de depuração:

using System.Diagnostics;

Debug.WriteLine("Send to debug output.");

Usar:

System.Diagnostics.Debug.WriteLine("your message here");

Debug.WriteLine

é o que você está procurando.

Caso contrário, tente fazer o seguinte:

Ferramentas do menu → Opções → Depuração → desmarque Enviar saída para imediato .

Para mim, apenas o namespace Trace e não o Debug funcionaram:

System.Diagnostics.Trace.WriteLine("message");

Estou trabalhando em um projeto C # no Visual Studio 2010.

Você pode estar procurando

MessageBox.Show()

ou

Debug.Writeline()

A chamada

System.Diagnostics.Debug.WriteLine("message");

falha ao trabalhar com o .NET Core (V 1.0 ou 1.1).

Deveríamos criar e usar um logger de Microsoft.Extensions.Logging, mas esse log aparece apenas na janela do console pop-up do dotnet.exe, não na janela Saída do Visual Studio.

Isso requer uma estrutura de terceiros, ou seja, o Serilog , mas mesmo assim achei uma experiência muito tranquila com a obtenção de saída para algum lugar que eu possa ver.

Você primeiro precisa instalar o coletor Trace do Serilog . Depois de instalado, você precisa configurar o logger da seguinte maneira:

Logger = new LoggerConfiguration()
    .MinimumLevel.Verbose()
    .WriteTo.Trace()
    .CreateLogger();

(Você pode definir um nível mínimo diferente ou defini-lo como um valor de configuração ou qualquer uma das funcionalidades normais do Serilog. Você também pode definir o criador de Tracelogs para um nível específico para substituir as configurações, ou como desejar.)

Então você apenas registra as mensagens normalmente e elas são exibidas na janela Saída:

Logger.Information("Did stuff!");

Isso não parece tão importante, então deixe-me explicar algumas vantagens adicionais. O maior para mim foi o fato de eu poder fazer logon simultaneamente na janela Saída e no console :

Logger = new LoggerConfiguration()
    .MinimumLevel.Verbose()
    .WriteTo.Trace()
    .WriteTo.Console(standardErrorFromLevel: LogEventLevel.Error)
    .CreateLogger();

Isso me deu uma grande flexibilidade em termos de como eu consumi a saída, sem ter que duplicar todas as minhas chamadas Console.Writecom Debug.Write. Ao escrever o código, eu poderia executar minha ferramenta de linha de comando no Visual Studio sem medo de perder minha saída quando ela saísse. Quando eu o implantei e precisei depurar algo (e não tinha o Visual Studio disponível), a saída do console estava prontamente disponível para o meu consumo. As mesmas mensagens também podem ser registradas em um arquivo (ou qualquer outro tipo de coletor) quando estiver sendo executado como uma tarefa agendada.

O ponto principal é que o uso do Serilog para isso facilitou o despejo de mensagens para vários destinos, garantindo que eu sempre pudesse acessar prontamente a saída, independentemente de como a executei.

Também requer configuração e código mínimos.

Esta não é uma resposta para a pergunta original. Mas como encontrei essa pergunta ao procurar um meio de despejar interativamente dados de objetos, imaginei que outros poderiam se beneficiar ao mencionar essa alternativa muito útil.

Eu finalmente usei a janela de comando e digitei o Debug.Printcomando, como mostrado abaixo. Isso imprimiu um objeto de memória em um formato que pode ser copiado como texto, o que é tudo o que eu realmente precisava.

> Debug.Print <item>

  id: 1
  idt: null
  igad: 99
  igbd: 99
  gl_desc: "New #20"
  te_num: "1-001-001-020"

Imprima na janela de saída do Visual Studio:

Debug.Writeline();

O seguinte funcionou para mim no Visual Studio 2015:

OutputDebugStringW(L"Write this to Output window in VS14.");

Leia a documentação para OutputDebugStringW aqui .

Observe que esse método só funciona se você estiver depurando seu código ( debug mode)

Para fins de depuração, o System.Diagnostics.Debug.Writeline()comando não será compilado na versão do código, a menos que você tenha ouvintes de depuração. Ele grava em todos os ouvintes de rastreamento, que incluem a janela de saída do VS ao executar no modo Debug.

Para um aplicativo de console. Console.Writeline()funcionaria, mas a saída ainda seria gerada na versão de lançamento do seu binário.

A saída de depuração também deve aparecer na janela de saída normal ao depurar testes; enquanto que a saída console.writeline não existe (mas pode ser encontrada na janela de saída de teste).