Куда идет Console.WriteLine в отладке?

Он переходит в консоль (стандартный вывод) или в поток, на который настроена консоль.

Console.writeline () переходит в окно консоли: черная подсказка command / dos.

Даже в приложении WinForms вы можете создать окно консоли, но вам придется пройти через P / Invoke, чтобы напрямую вызвать метод Win32. См. http://pinvoke.net/default.aspx/kernel32/AllocConsole.html

Отладка и выпуск не влияют на то, получите ли вы окно консоли. Это контролируется типом вывода проекта. (Свойства -> Приложение -> Тип вывода). Консольное приложение предоставит вам окно консоли, которое будет визуализировать и получать входные данные из окна в потоки Error, In и Out в System.Console.

Класс System.Console предоставляет несколько свойств и методов для взаимодействия со своими потоками, даже если вы его не видите. В частности: Error, In, Out, SetError (), SetIn (), SetOut () и методы чтения и записи.

NullStream, который определяется как «поток без резервного хранилища». Все методы ничего не делают или ничего не возвращают. Это внутренний класс для Stream. Следующий код взят из исходного кода Microsoft.

Обычно, когда один из методов записи Console вызывается в первый раз, выполняется вызов функции Windows API GetStdHandle для «стандартного вывода». Если дескриптор не возвращается, создается и используется NullStream.

Ответ Самуэля правильный и дает общую информацию. Чтобы фактически перенаправить вывод консоли, независимо от типа проекта, используйте Console.SetOut(New System.IO.StreamWriter("C:\ConsoleOutput.txt")), который является простым примером.

Направление консоли, отладки и трассировки в файл

Чтобы ответить на ваш вопрос прямо. Используйте ConsoleTraceListener и StreamWriter, чтобы направить все три вывода в файл. Следующее я использую только для разработки.

    Dim oLogFile As New System.IO.StreamWriter("C:\ConsoleOutput.txt")
    oLogFile.AutoFlush = True 'so we do not have to worry about flushing before application exit

    Console.SetOut(oLogFile)

    'note, writing to debug and trace causes output on console, so you will get double output in log file
    Dim oListener As New ConsoleTraceListener
    Debug.Listeners.Add(oListener)
    Trace.Listeners.Add(oListener)

NullStream

[Serializable]
private sealed class NullStream : Stream {
    internal NullStream() { }

    public override bool CanRead {
        get { return true; }
    }

    public override bool CanWrite {
        get { return true; }
    }

    public override bool CanSeek {
        get { return true; }
    }

    public override long Length {
        get { return 0; }
    }

    public override long Position {
        get { return 0; }
        set { }
    }

    // No need to override Close

    public override void Flush() {
    }

    public override int Read([In, Out] byte[] buffer, int offset, int count) {
        return 0;
    }

    public override int ReadByte() {
        return -1;
    }

    public override void Write(byte[] buffer, int offset, int count) {
    }

    public override void WriteByte(byte value) {
    }

    public override long Seek(long offset, SeekOrigin origin) {
        return 0;
    }

    public override void SetLength(long length) {
    }
} 

Я на самом деле поддержу Джеймса в этом.

http://www.csharp411.com/console-output-from-winforms-application

описывает его очень подробно (если достаточно направить вывод в файл, тогда вы можете легко использовать метод amissico). Большинство описанных в них методов имитируют методы, описанные в http://dslweb.nwnexus.com/~ast/dload/guicon.htm.

Как уже упоминалось, изменение вашего проекта на «консольный» будет иметь аналогичный эффект. Ваше здоровье!

Консоль может перенаправить вывод на любой текстовый редактор. Если вы реализуете текстовый редактор, который пишет в Diagnostics.Debug, все готово.

Вот текстовый редактор, который пишет в отладчик.

using System.Diagnostics;
using System.IO;
using System.Text;

namespace TestConsole
{
    public class DebugTextWriter : TextWriter
    {
        public override Encoding Encoding
        {
            get { return Encoding.UTF8; }
        }

        //Required
        public override void Write(char value)
        {
            Debug.Write(value);
        }

        //Added for efficiency
        public override void Write(string value)
        {
            Debug.Write(value);
        }

        //Added for efficiency
        public override void WriteLine(string value)
        {
            Debug.WriteLine(value);
        }
    }
}

Поскольку он использует Diagnostics.Debug, он будет придерживаться настроек вашего компилятора, чтобы он мог писать какой-либо вывод или нет. Этот вывод также можно увидеть в Sysinternals DebugView.

Вот как вы это используете:

using System;

namespace TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.SetOut(new DebugTextWriter());
            Console.WriteLine("This text goes to the Visual Studio output window.");
        }
    }
}

Если вы хотите видеть вывод в Sysinternals DebugView при компиляции в режиме выпуска, вы можете использовать TextWriter, который записывает в OutputDebugString API. Это могло выглядеть так:

using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace TestConsole
{
    public class OutputDebugStringTextWriter : TextWriter
    {
        [DllImport("kernel32.dll")]
        static extern void OutputDebugString(string lpOutputString);

        public override Encoding Encoding
        {
            get { return Encoding.UTF8; }
        }

        //Required
        public override void Write(char value)
        {
            OutputDebugString(value.ToString());
        }

        //Added for efficiency
        public override void Write(string value)
        {
            OutputDebugString(value);
        }

        //Added for efficiency
        public override void WriteLine(string value)
        {
            OutputDebugString(value);
        }
    }
}

Visual Studio запускает программы Windows (/target:winexe) с помощью stdin / stdout / stderr перенаправлен для именованных каналов. Другой конец каждого канала принадлежит отладчику VS, и все, что читается на stderr / stdout, отображается в окне вывода отладки. Следовательно, Console.Write автоматически появляется в выводе VS Debug. Обратите внимание, что этого не происходит, если вы прикреплять к уже запущенному процессу (поскольку трюк с перенаправлением может быть выполнен только во время запуска процесса).

При запуске консольных программ (/target:exe) этого перенаправления не происходит, поэтому Console.Write переходит на фактическую консоль (или куда перенаправляется stdout).

Я не смог найти ничего, что документировало бы это поведение, это просто мой вывод из исследования того, как VS запускает и отлаживает приложения.

Лучшим решением для меня было изменить Console.WriteLine () на System.Diagnostics.Debug.WriteLine (). Например:

 catch (DbEntityValidationException dbEx)
 {
    foreach (var validationErrors in dbEx.EntityValidationErrors)
    {
       foreach (var validationError in validationErrors.ValidationErrors)
       {
          System.Diagnostics.Debug.WriteLine("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
       }
    }

Затем вы можете просматривать свои ошибки как объект в окне вывода.

Как уже прокомментировали вопрос OP:

Не нужно писать дополнительный код

В верхнем меню Visual Studio выберите

Debug > Windows > Output

Окна вывода будут видны только в режиме отладки, и они будут отображать все, например. Console.WriteLine("Debug MyVariable: " + MyVariable) когда вы доберетесь до них.

Установите точку останова перед (щелкните пустую область разного цвета перед номером строки в начале выбранной строки), выполните отладку (F5), а затем пошагово выполняйте код построчно (F11), пока не сделаете это.