.net - password - wildfly no console active

¿Dónde entra Console.WriteLine en Debug?

Question

Encontré esta pregunta , pero lo que quiero saber es diferente: ¿el resultado de Console.WriteLine va a algún lado cuando se depura? Sé que para que vaya a la ventana de salida debería Debug.WriteLine () u otros métodos, pero ¿dónde va el Console.WriteLine () estándar?

Editar Cuando se depura, no se ve la ventana negra de la consola / registro de prueba, por lo que la verdadera pregunta es ¿cómo puedo acceder / ver esta salida durante la depuración?

Answer 1

Console.writeline () va a una ventana de consola: el comando black command / dos.

Answer 2

Depurar y liberar no controla si obtienes o no una ventana de consola. Eso está controlado por el tipo de salida del proyecto. (Propiedades -> Aplicación -> Tipo de salida). La aplicación de consola le proporcionará una ventana de consola que visualizará y recibirá la entrada de la ventana en las secuencias de error, entrada y salida en System.Console.

La clase System.Console expone varias propiedades y métodos para interactuar con sus transmisiones, incluso si no puede verlas. En particular: Error, In, Out, SetError (), SetIn (), SetOut () y los métodos de lectura y escritura.

Answer 3

Incluso en una aplicación WinForms, puede crear una ventana de consola, pero tendrá que pasar por P / Invoke para llamar directamente a un método Win32. Ver http://pinvoke.net/default.aspx/kernel32/AllocConsole.html

Answer 4

Va a la consola (salida estándar) o a la secuencia en la que está configurada la consola.

Answer 5

NullStream , que se define como "A Stream sin tienda de respaldo". Todos los métodos no hacen nada ni devuelven nada. Es una clase interna a Stream . El siguiente código está tomado del código fuente de Microsoft.

Básicamente, cuando uno de los métodos de escritura de la Console se llama por primera vez, se realiza una llamada a la función API de Windows GetStdHandle para "salida estándar". Si no se devuelve ningún NullStream se crea y utiliza un NullStream .

La respuesta de Samuel es correcta y proporciona información general. Para redirigir realmente la salida de la consola, independientemente del tipo de proyecto, use Console.SetOut(New System.IO.StreamWriter("C:/ConsoleOutput.txt")) , que es un ejemplo simple.

Dirigir la consola, depurar y rastrear al archivo

Para responder a tu pregunta directamente. Use ConsoleTraceListener y StreamWriter para dirigir las tres salidas a un archivo. Uso lo siguiente solo para desarrollo.

    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) {
    }
} 

Answer 6

En realidad voy a secundar a James en este caso.

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

lo describe en detalle (si dirigir la salida a un archivo es suficiente, entonces puedes usar fácilmente el método de amissico). La mayoría de los métodos que describen imitan a los descritos en http://dslweb.nwnexus.com/~ast/dload/guicon.htm

Cambiar su proyecto a un proyecto de "consola" tendría un efecto similar, como se mencionó. ¡Aclamaciones!

Answer 7

La consola puede redirigir su salida a cualquier editor de textos. Si implementa una máquina de escribir que escribe en Diagnostics.Debug, ya está todo listo.

Aquí hay un escritor de textos que escribe en el depurador.

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);
        }
    }
}

Como utiliza Diagnostics.Debug, se ajustará a la configuración del compilador para saber si debe escribir alguna salida o no. Este resultado también se puede ver en Sysinternals DebugView.

Así es como lo usa:

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.");
        }
    }
}

Si desea ver el resultado en Sysinternals DebugView cuando está compilando en modo Release, puede usar un TextWriter que escribe en OutputDebugString API. Podría verse así:

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);
        }
    }
}

Answer 8

Visual Studio inicia los programas de Windows ( /target:winexe ) con stdin / stdout / stderr redirigido a /target:winexe con nombre. El otro extremo de cada tubería es propiedad del depurador VS y todo lo que se lee en stderr / stdout se muestra en la ventana de salida de depuración. Por lo tanto, Console.Write aparece automáticamente en la salida VS Debug. Tenga en cuenta que esto no ocurre si se conecta a un proceso ya iniciado (ya que el truco de redirección solo se puede realizar en el momento del inicio del proceso).

Al ejecutar los programas de la consola ( /target:exe ), esta redirección no se produce, por lo que Console.Write va a la consola real (o donde sea que se redirija la stdout ).

No pude encontrar nada que documente este comportamiento, es solo mi conclusión al investigar cómo VS lanza y depura aplicaciones.