redirige la consola a la ventana de salida de depuración de Visual Studio en app.config

Question

Quiero que mis comandos Console.WriteLine() aparezcan en mi ventana "Salida" con mis declaraciones Debug.WriteLine(). Creo que descubrí cómo hacer esto una vez, pero no puedo recordar/encontrar en google cómo hacerlo de nuevo. Me parece recordar que ser capaz de hacer esto en el app.config

encuentro un montón de instrucciones sobre cómo apostar declaraciones de consola y depurar a aparecer en la salida de la consola, pero no la forma de conseguir que aparecen en el " Salida "ventana".

¿Alguien sabe?

Answer 1

Básicamente, la solución más simple es la siguiente.

public class ToDebugWriter : StringWriter 
    { 
     public override void WriteLine(string value) 
     { 
      Debug.WriteLine(value); 
      base.WriteLine(value); 
     } 
    } 

y debe agregar a la inicialización del programa de esta línea "Console.SetOut (nueva ToDebugWriter());"

Answer 2

Si puede obtener la secuencia para la ventana de salida, puede usar Console.SetOut() para redirigir a ella. Sin embargo, este enfoque no parece ser posible.

System.Debug salidas a cada TraceListener en su TraceListenerCollection. Solo hay un TraceListener registrado inicialmente que es el DefaultTraceListener. No hace uso de un objeto de transmisión y en su lugar utiliza métodos nativos para la salida.

Un enfoque que utiliza la API de Visual Studio es probablemente el camino a seguir.

Answer 3

@Avram's answer me ha funcionado, excepto que la única sobrecarga en su código no era la que el ConsoleAppender de log4net estaba usando en mi sistema. (Estoy interesado en Console.SetOut por lo ConsoleAppender salidas de ese log4net a panel de Visual Studio "depuración" de salida.) Así que anularon todos Write y WriteLine métodos StringWriter 's aceptar string, object, char[], etc., en el supuesto de que uno o más de estos era lo que llamaba ConsoleAppender a través del Console.

Esto se realizó correctamente, y el registro log4net ahora aparece en mi panel "Debug".

Estoy incluyendo el siguiente código para el beneficio de cualquier persona con objetivos similares. (Para estar totalmente seguro, se pueden anular los métodos StringWriter.Write y .WriteLine restantes). Eliminé las llamadas al base porque parecen ser innecesarias, y creo que simplemente crean un gran búfer dentro de StringWriter (generalmente se accede a través de esa clase .ToString().)

namespace GeneralLibrary.Logging 
{ 
    using System.Diagnostics; 
    using System.IO; 

    public class DebugWriter : StringWriter 
    { 
     public override void Write(string format, object arg0) 
     { 
      Debug.Write(string.Format(format, arg0)); 
     } 

     public override void Write(string format, object arg0, object arg1) 
     { 
      Debug.Write(string.Format(format, arg0, arg1)); 
     } 

     public override void Write(string format, object arg0, object arg1, object arg2) 
     { 
      Debug.Write(string.Format(format, arg0, arg1, arg2)); 
     } 

     public override void Write(string format, params object[] arg) 
     { 
      Debug.Write(string.Format(format, arg)); 
     } 

     public override void Write(object value) 
     { 
      Debug.Write(value); 
     } 

     public override void Write(string value) 
     { 
      Debug.Write(value); 
     } 

     public override void Write(char[] buffer) 
     { 
      Debug.Write(buffer); 
     } 

     public override void Write(char[] buffer, int index, int count) 
     { 
      Debug.Write(new string(buffer, index, count)); 
     } 

     public override void WriteLine(string value) 
     { 
      Debug.WriteLine(value); 
     } 

     public override void WriteLine(object value) 
     { 
      Debug.WriteLine(value); 
     } 

     public override void WriteLine(string format, object arg0) 
     { 
      Debug.WriteLine(format, arg0); 
     } 

     public override void WriteLine(string format, object arg0, object arg1) 
     { 
      Debug.WriteLine(format, arg0, arg1); 
     } 

     public override void WriteLine(string format, object arg0, object arg1, object arg2) 
     { 
      Debug.WriteLine(format, arg0, arg1, arg2); 
     } 

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

     public override void WriteLine(char[] buffer) 
     { 
      Debug.WriteLine(buffer); 
     } 

     public override void WriteLine(char[] buffer, int index, int count) 
     { 
      Debug.WriteLine(new string(buffer, index, count)); 
     } 

     public override void WriteLine() 
     { 
      Debug.WriteLine(string.Empty); 
     } 
    } 
}