Having the output of a console application in Visual Studio instead of the console

When doing a console application in Java with Eclipse, I see the output being put in a text box in the IDE itself, instead of having a console popping up like in Visual Studio. This comes in handy, as even after the program has exited, I can still make good use of the text that was written in it, as it doesn't get erased until I run it again. Is it possible to achieve anything like that with Visual Studio? I know that inst开发者_JAVA技巧ead of doing

System.Console.WriteLine(str);

I can do

System.Diagnostics.Debug.WriteLine(str);

but it is not quite the same thing, as you get a lot of "junk" in the Output window, as all the loaded symbols and such.

Even better, is it possible to have everything done in the IDE itself, when you run your application, instead of having the console running?

In the Tools -> Visual Studio Options Dialog -> Debugging -> Check the "Redirect All Output Window Text to the Immediate Window".

In the Visual Studio Options Dialog -> Debugging -> Check the "Redirect All Output Window Text to the Immediate Window". Then go to your project settings and change the type from "Console Application" to "Windows Application". At that point Visual Studio does not open up a console window anymore, and the output is redirected to the Output window in Visual Studio. However, you cannot do anything "creative", like requesting key or text input, or clearing the console - you'll get runtime exceptions.

Use System.Diagnostics.Trace

Depending on what listeners you attach, trace output can go to the debug window, the console, a file, database, or all at once. The possibilities are literally endless, as implementing your own TraceListener is extremely simple.

It's time to check the latest release/s for Visual Studio, folks. The most suggested solution that did not work for some of you before might work now.

In Visual Studio 2017 (Release Version 15.4.2 and above), going to Tools > Options > Debugging > General > (Check Box) Redirect all Output Window text to Immediate Window has worked for me.

Few Notes:

1. To see the Immediate Window, make sure that you are in Debugging mode.
2. There should now be 3 other debugging tools available at your disposal, namely, Call Stack, Breakpoints, and Command Window, as shown below:

Best wishes!

You can try VSConsole which allow you to integrate its console window inside VisualStudio as dock panel at bottom. To use this you have to

• Add VSCodeExtension to VisualStudio
• Add VSCode NugetPackage reference in your project.
• Add using Console = VSConsole.Console; as namespace reference in *.cs file
• change the Output type from Console Application to Windows Application to hide the main console window that pops up when you run your console application.

Then your application will use VSConsole.Console class insted of System.Console class.

You could create a wrapper application that you run instead of directly running your real app. The wrapper application can listen to stdout and redirect everything to Trace. Then change the run settings to launch your wrapper and pass in the path to the real app to run.

You could also have the wrapper auto-attach the debugger to the new process if a debugger is attached to the wrapper.

A simple solution that works for me, to work with console ability(ReadKey, String with Format and arg etc) and to see and save the output:

I write TextWriter that write to Console and to Trace and replace the Console.Out with it.

if you use Dialog -> Debugging -> Check the "Redirect All Output Window Text to the Immediate Window" you get it in the Immediate Window and pretty clean.

my code: in start of my code:

Console.SetOut(new TextHelper());

and the class:

public class TextHelper : TextWriter
{
    TextWriter console;

    public TextHelper() {
        console = Console.Out;
    }

    public override Encoding Encoding => this.console.Encoding;

    public override void WriteLine(string format, params object[] arg)
    {
        string s = string.Format(format, arg);
        WriteLine(s);
    }

    public override void Write(object value)
    {
        console.Write(value);
        System.Diagnostics.Trace.Write(value);
    }

    public override void WriteLine(object value)
    {
        Write(value);
        Write("\n");
    }

    public override void WriteLine(string value)
    {
        console.WriteLine(value);
        System.Diagnostics.Trace.WriteLine(value);
    }
}

Note: I override just what I needed so if you write other types you should override more

If you are using same methods on Console that are available in Debug class like Console.WriteLine(string) then in .net core you can add below line as your 1'st line in program.cs file.

global using Console = System.Diagnostics.Debug;
using System.Diagnostics;

Now all your call for Console.WriteLine(string) are executed as Debug.WriteLine(string) in all *.cs files in project. At places where you want to explicitly use console methods like Console.Readline() then you have to replace it with fully qualified class name System.Console.ReadLine().

Now output from all your Console.WriteLine(string) is now visible in Visualstudio output window. You can further filter out noise in output window by selecting what type of messages you want to see in that window as shown below

I know this is just another answer, but I thought I'd write something down for the new Web Developers, who might get confused about the "Change to a Windows Application" part, because I think by default an MVC application in Visual Studio 2013 defaults to an Output Type of Class Library.

My Web Application by default is set as an output type of "Class Library." You don't have to change that. All I had to do was follow the suggestions of going to Tools > Options > Debugging > Redirect all Output Window text to the Immediate Window. I then used the System.Diagnostics.Trace suggestion by Joel Coehoorn above.

Instead, you can collect the output in a test result.

You can't supply input, but you can easily provide several tests with different command line arguments, each test collecting the output.

If your goal is debugging, this is a low effort way of offering a repeatable debugging scenario.

namespace Commandline.Test
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    [TestClass]
    public class CommandlineTests
    {
        [TestMethod]
        public void RunNoArguments()
        {
            Commandline.Program.Main(new string[0]);
        }
    }
}

regarding System.Diagnostics.Debug producing a lot of "junk" in the Output window: You can turn that off by right clicking in the output window. E.g. there's an item "Module Load Messages" which you want to disable and an item "Program Output" which you want to keep.

You have three possibilities to do this, but it's not trivial. The main idea of all IDEs is that all of them are the parents of the child (debug) processes. In this case, it is possible to manipulate with standard input, output and error handler. So IDEs start child applications and redirect out into the internal output window. I know about one more possibility, but it will come in future

1. You could implement your own debug engine for Visual Studio. Debug Engine control starting and debugging for application. Examples for this you could find how to do this on learn.microsoft.com (Visual Studio Debug engine)
2. Redirect form application using duplication of std handler for c++ or use Console.SetOut(TextWriter) for c#. If you need to print into the output window you need to use Visual Studio extension SDK. Example of the second variant you could find on Github.
3. Start application that uses System.Diagnostics.Debug.WriteLine (for printing into output) and than it will start child application. On starting a child, you need to redirect stdout into parent with pipes. You could find an example on MSDN. But I think this is not the best way.

If you need output from Console.WriteLine, and the Redirect All Output Window Text to the Immediate Window does not function and you need to know the output of Tests from the Integrated Test Explorer, using NUnit.Framework our problem is already solved at VS 2017:

Example taken from C# In Depth by Jon Skeet:

When we click on Blue Output, under Elapsed Time, at right, and it produces this:

Standard Output is our desired Output, produced by Console.WriteLine.

It functions for Console and for Windows Form Applications at VS 2017, but only for Output generated for Test Explorer at Debug or Run; anyway, this is my main need of Console.WriteLine output.