Rediriger la console vers la fenêtre de sortie de débogage Visual Studio dans app.config

Question

Je souhaite que mes commandes Console.WriteLine () apparaissent dans mon "résultat". fenêtre avec mes instructions Debug.WriteLine () . Je pense avoir compris comment faire cela une fois, mais je ne me souviens pas / ne trouve pas sur Google comment le faire à nouveau. Il me semble me souvenir de pouvoir le faire dans le fichier app.config .

Je trouve que de nombreuses instructions expliquent comment obtenir des instructions de console et de débogage dans la sortie de la console, mais pas comment les obtenir dans le "résultat". fenêtre.

Est-ce possible?

Answer 1

En gros, la solution la plus simple ressemble à ceci.

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

Et vous devez ajouter cette ligne à l'initialisation du programme:

Console.SetOut(new ToDebugWriter());

Answer 2

La réponse de @ Avram a fonctionné pour moi, à l'exception du fait que la surcharge unique dans son code n'était pas celle utilisée par log4net. ConsoleAppender était utilisé sur mon système. (Je suis intéressé par Console.SetOut pour que ConsoleAppender de log4net soit affiché dans le volet de sortie "Débogage" de Visual Studio.) J'ai donc écrasé la totalité de StringWriter des méthodes Write WriteLine acceptant chaîne , objet , char [] , etc., en supposant qu’un ou plusieurs d’entre eux correspondaient à ce que ConsoleAppender appelait via Console .

Cela a réussi et la journalisation log4net apparaît maintenant dans mon " Débogage " vitre.

J'inclus le code ci-dessous dans l'intérêt de toute personne ayant des objectifs similaires. (Pour être tout à fait sûr, vous pouvez remplacer les méthodes StringWriter.Write et .WriteLine restantes.) J'ai supprimé les appels à base car ils semblent être inutiles, et je pense qu'ils construisent juste un grand tampon dans StringWriter (généralement accessible via le .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);
        }
    }
}

Answer 3

Si vous pouvez vous procurer le flux pour la fenêtre de sortie, vous pouvez utiliser Console.SetOut () pour y accéder. Cependant, cette approche ne semble pas être possible.

System.Debug est envoyé à chaque < a href = "http://msdn.microsoft.com/en-us/library/system.diagnostics.tracelistener.aspx" rel = "aucune erreur de suivi"> TraceListener dans son TraceListenerCollection . Au départ, il n’existe qu’un seul TraceListener qui soit le DefaultTraceListener . Il n'utilise pas d'objet de flux mais utilise des méthodes natives pour la sortie.

Une approche qui utilise l'API de Visual Studio est probablement la solution.