Writing to output window of Visual Studio

I am trying to write a message to the output window for debugging purposes. I searched for a function like Java's system.out.println(""). I tried Debug.Write, Console.Write, and Trace.Write. It does not give an error, but it does not print anything either.

"Define DEBUG constant" and "Define TRACE constant" options are checked.

Menu ToolsOptionsDebugging"Redirect all Output Window text to the Immediate Window" option is not checked.

Configuration: Active (Debug)

Note: I created a project with the wizard as "Windows Forms Application" if relevant. I have no idea where to look.


Add the System.Diagnostics namespace, and then you can use Debug.WriteLine() to quickly print a message to the output window of the IDE. For more details, please refer to these:

This will write to the debug output window:

using System.Diagnostics;

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


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


is what you're looking for.

If not, try doing this:

Menu ToolsOptionsDebugging → uncheck Send Output to Immediate.

For me, only the Trace namespace and not the Debug one worked:


I'm working in a C# project under Visual Studio 2010.

You may be looking for




The call


fails when working with .NET Core (V 1.0 or 1.1).

We are supposed to create and use a logger from Microsoft.Extensions.Logging, but that log only appears in the dotnet.exe popup console window, not in Visual Studio's Output window.

This requires a third party framework, namely Serilog, but I've nonetheless found it to be a very smooth experience with getting output to some place I can see it.

You first need to install Serilog's Trace sink. Once installed, you need to set up the logger like this:

Logger = new LoggerConfiguration()

(You can set a different minimum level or set it to a config value or any of the normal Serilog functionality. You can also set the Trace logger to a specific level to override configs, or however you want to do this.)

Then you just log messages normally and they show up in your Output window:

Logger.Information("Did stuff!");

This doesn't seem like such a big deal, so let me explain some additional advantages. The biggest one for me was that I could simultaneously log to both the Output window and the console:

Logger = new LoggerConfiguration()
    .WriteTo.Console(standardErrorFromLevel: LogEventLevel.Error)

This gave me great flexibility in terms of how I consumed output, without having to duplicate all my calls to Console.Write with Debug.Write. When writing the code, I could run my command line tool in Visual Studio without fear of losing my output when it exited. When I had deployed it and needed to debug something (and didn't have Visual Studio available), the console output was readily available for my consumption. The same messages can also be logged to a file (or any other kind of sink) when it's running as a scheduled task.

The bottom line is that using Serilog to do this made it really easy to dump messages to a multitude of destinations, ensuring I could always readily access the output regardless of how I ran it.

It also requires very minimal set up and code.

This is not an answer to the original question. But since I found this question when searching for a means of interactively dumping object data, I figured others may benefit from mentioning this very useful alternative.

I ultimately used the Command Window and entered the Debug.Print command, as shown below. This printed a memory object in a format that can be copied as text, which is all I really needed.

> Debug.Print <item>

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

The following worked for me in Visual Studio 2015:

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

Read the documentation for OutputDebugStringW here.

Note that this method only works if you are debugging your code (debug mode)

Print to the output window of the Visual Studio:


For debugging purposes, the System.Diagnostics.Debug.Writeline() command will not be compiled into the release version of your code unless you have debug listeners. It writes to all trace listeners which includes the VS output window when running in Debug mode.

For a Console application. Console.Writeline() would work but the output would still be generated in the release version of your binary.

Debug output should also appear in the normal output window when debugging tests; whereas, console.writeline output does not (but can be found in the test output window.)

Need Your Help

Plot two histograms at the same time with matplotlib

python matplotlib plot histogram

I created a histogram plot using data from a file and no problem. Now I wanted to superpose data from

How to tell if the sdcard is mounted in Android?

android android-sdcard

I'm working on an Android application that needs to look at what images a user has stored. The problem is that if the user has the sdcard mounted via the USB cable, I can't read the list of images...