Keine Ausgabe von einer WPF-Anwendung zu trösten?

Question

Ich bin mit Console.WriteLine () aus einer sehr einfachen WPF Testanwendung, aber wenn ich die Anwendung von der Kommandozeile ausführen, ich sehe nichts auf die Konsole geschrieben werden. Weiß jemand, was hier könnte da los?

Ich kann es reproduzieren, indem Sie eine WPF-Anwendung in VS 2008 erstellen und einfach Console.WriteLine Zugabe ( „text“) überall, die ausgeführt werden soll. Irgendwelche Ideen?

Alles, was ich jetzt brauchen, ist etwas so einfaches wie Console.WriteLine (). Ich weiß, ich log4net oder SOMET andere Logging-Lösung verwenden könnte, aber ich wirklich nicht so viel Funktionalität für diese Anwendung benötigen.

Edit: Ich sollte daran erinnert, dass Console.WriteLine () für Konsolenanwendungen ist. Na ja, keine dummen Fragen, nicht wahr? :-) Ich werde nur verwenden System.Diagnostics.Trace.WriteLine () und Debugview für jetzt.

Answer 1

Sie werden ein Konsolenfenster erstellen müssen manuell, bevor Sie Console.Write Methoden tatsächlich nennen. Das wird die Konsole init richtig zu arbeiten, ohne den Projekttyp zu ändern (was für WPF-Anwendung wird nicht funktionieren).

Hier ist ein vollständiges Quellcode Beispiel dafür, wie eine ConsoleManager Klasse aussehen könnte, und wie es verwendet werden kann, um die Konsole zu aktivieren / deaktivieren, unabhängig vom Projekttyp.

Mit der folgenden Klasse, brauchen Sie nur ConsoleManager.Show() irgendwo zu schreiben, bevor ein Anruf Console.Write ...

[SuppressUnmanagedCodeSecurity]
public static class ConsoleManager
{
    private const string Kernel32_DllName = "kernel32.dll";

    [DllImport(Kernel32_DllName)]
    private static extern bool AllocConsole();

    [DllImport(Kernel32_DllName)]
    private static extern bool FreeConsole();

    [DllImport(Kernel32_DllName)]
    private static extern IntPtr GetConsoleWindow();

    [DllImport(Kernel32_DllName)]
    private static extern int GetConsoleOutputCP();

    public static bool HasConsole
    {
        get { return GetConsoleWindow() != IntPtr.Zero; }
    }

    /// <summary>
    /// Creates a new console instance if the process is not attached to a console already.
    /// </summary>
    public static void Show()
    {
        //#if DEBUG
        if (!HasConsole)
        {
            AllocConsole();
            InvalidateOutAndError();
        }
        //#endif
    }

    /// <summary>
    /// If the process has a console attached to it, it will be detached and no longer visible. Writing to the System.Console is still possible, but no output will be shown.
    /// </summary>
    public static void Hide()
    {
        //#if DEBUG
        if (HasConsole)
        {
            SetOutAndErrorNull();
            FreeConsole();
        }
        //#endif
    }

    public static void Toggle()
    {
        if (HasConsole)
        {
            Hide();
        }
        else
        {
            Show();
        }
    }

    static void InvalidateOutAndError()
    {
        Type type = typeof(System.Console);

        System.Reflection.FieldInfo _out = type.GetField("_out",
            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);

        System.Reflection.FieldInfo _error = type.GetField("_error",
            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);

        System.Reflection.MethodInfo _InitializeStdOutError = type.GetMethod("InitializeStdOutError",
            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);

        Debug.Assert(_out != null);
        Debug.Assert(_error != null);

        Debug.Assert(_InitializeStdOutError != null);

        _out.SetValue(null, null);
        _error.SetValue(null, null);

        _InitializeStdOutError.Invoke(null, new object[] { true });
    }

    static void SetOutAndErrorNull()
    {
        Console.SetOut(TextWriter.Null);
        Console.SetError(TextWriter.Null);
    }
} 

Answer 2

Direkt am Projekt klicken, „Eigenschaften“, „Application“ Registerkarte ändern „Ausgabetyp“ auf „Console Application“, und dann wird es auch eine Konsole hat.

Answer 3

Sie können mit

Trace.WriteLine("text");

Dies wird Ausgabe an die "Output" Fenster in Visual Studio (beim Debuggen).

sicherstellen, dass die Diagnose Assembly enthalten haben:

using System.Diagnostics;

Answer 4

Obwohl John Leidegren hält die Idee abzuschießen, ist Brian richtig. Ich habe gerade hätte es in Visual Studio arbeiten.

Um klar zu sein, eine WPF-Anwendung kein Konsolenfenster standardmäßig erstellen.

Sie haben eine WPF-Anwendung erstellen und dann den Output ändern zu „Console Application“. Wenn Sie das Projekt aufrufen, erscheint ein Konsolenfenster mit dem WPF-Fenster vor sich sehen.

Es sieht nicht sehr schön, aber ich fand es hilfreich, als ich meine App ausgeführt wird von der Kommandozeile mit Feedback in dort, und dann für bestimmte Befehlsoptionen wollte würde ich die WPF-Fenster angezeigt werden.

Answer 5

Es ist möglich, Ausgang für Konsole vorgesehen, um zu sehen von Kommandozeilen Umleitung .

Zum Beispiel:

C:\src\bin\Debug\Example.exe > output.txt

werden alle den Inhalt schreiben Datei output.txt.

Answer 6

Alte Post, aber ich in diesen lief so, wenn Sie die Ausgabe etwas Output in einem WPF-Projekt in Visual Studio sind versucht, die heutige Methode ist:

Fügen Sie diese:

using System.Diagnostics;

Und dann:

Debug.WriteLine("something");

Answer 7

Ich benutze Console.WriteLine () für die Verwendung im Ausgabefenster ...

Answer 8

Ich habe eine Lösung erstellen, die Informationen von Varius Post gemischt.

Es ist eine Form, die ein Etikett und ein Textfeld enthält. Die Konsolenausgabe in das Textfeld umgeleitet wird.

Es gibt auch eine Klasse namens Console die drei Öffentlichkeiten Methoden implementiert: Show (), Close () und Release (). Der letzte ist für verlassen die Konsole öffnen und auf die Schaltfläche Schließen für Ansicht Ergebnisse aktivieren.

Die Formulare werden FrmConsole genannt. Hier sind die XAML und C # -Code.

Die Verwendung ist sehr einfach:

ConsoleView.Show("Title of the Console");

Für die Konsole öffnen. Verwendung:

System.Console.WriteLine("The debug message");

Für die Ausgabe Text an die Konsole.

Verwendung:

ConsoleView.Close();

Schließen Sie die Konsole.

ConsoleView.Release();

Leaves die Konsole öffnen und ermöglicht die Schaltfläche Schließen

XAML

<Window x:Class="CustomControls.FrmConsole"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:CustomControls"
    mc:Ignorable="d"
    Height="500" Width="600" WindowStyle="None" ResizeMode="NoResize" WindowStartupLocation="CenterScreen" Topmost="True" Icon="Images/icoConsole.png">
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="40"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="40"/>
    </Grid.RowDefinitions>
    <Label Grid.Row="0" Name="lblTitulo" HorizontalAlignment="Center" HorizontalContentAlignment="Center" VerticalAlignment="Center" VerticalContentAlignment="Center" FontFamily="Arial" FontSize="14" FontWeight="Bold" Content="Titulo"/>
    <Grid Grid.Row="1">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="10"/>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="10"/>
        </Grid.ColumnDefinitions>
        <TextBox Grid.Column="1" Name="txtInner" FontFamily="Arial" FontSize="10" ScrollViewer.CanContentScroll="True" VerticalScrollBarVisibility="Visible" HorizontalScrollBarVisibility="Visible" TextWrapping="Wrap"/>
    </Grid>
    <Button Name="btnCerrar" Grid.Row="2" Content="Cerrar" Width="100" Height="30" HorizontalAlignment="Center" HorizontalContentAlignment="Center" VerticalAlignment="Center" VerticalContentAlignment="Center"/>
</Grid>

Der Code des Fensters:

partial class FrmConsole : Window
{
    private class ControlWriter : TextWriter
    {
        private TextBox textbox;
        public ControlWriter(TextBox textbox)
        {
            this.textbox = textbox;
        }

        public override void WriteLine(char value)
        {
            textbox.Dispatcher.Invoke(new Action(() =>
            {
                textbox.AppendText(value.ToString());
                textbox.AppendText(Environment.NewLine);
                textbox.ScrollToEnd();
            }));
        }

        public override void WriteLine(string value)
        {
            textbox.Dispatcher.Invoke(new Action(() =>
            {
                textbox.AppendText(value);
                textbox.AppendText(Environment.NewLine);
                textbox.ScrollToEnd();
            }));
        }

        public override void Write(char value)
        {
            textbox.Dispatcher.Invoke(new Action(() =>
            {
                textbox.AppendText(value.ToString());
                textbox.ScrollToEnd();
            }));
        }

        public override void Write(string value)
        {
            textbox.Dispatcher.Invoke(new Action(() =>
            {
                textbox.AppendText(value);
                textbox.ScrollToEnd();
            }));
        }

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

        }
    }

    //DEFINICIONES DE LA CLASE
    #region DEFINICIONES DE LA CLASE

    #endregion


    //CONSTRUCTORES DE LA CLASE
    #region CONSTRUCTORES DE LA CLASE

    public FrmConsole(string titulo)
    {
        InitializeComponent();
        lblTitulo.Content = titulo;
        Clear();
        btnCerrar.Click += new RoutedEventHandler(BtnCerrar_Click);
        Console.SetOut(new ControlWriter(txtInner));
        DesactivarCerrar();
    }

    #endregion


    //PROPIEDADES
    #region PROPIEDADES

    #endregion


    //DELEGADOS
    #region DELEGADOS

    private void BtnCerrar_Click(object sender, RoutedEventArgs e)
    {
        Close();
    }

    #endregion


    //METODOS Y FUNCIONES
    #region METODOS Y FUNCIONES

    public void ActivarCerrar()
    {
        btnCerrar.IsEnabled = true;
    }

    public void Clear()
    {
        txtInner.Clear();
    }

    public void DesactivarCerrar()
    {
        btnCerrar.IsEnabled = false;
    }

    #endregion  
}

Sie den Code der Klasse Console

static public class ConsoleView
{
    //DEFINICIONES DE LA CLASE
    #region DEFINICIONES DE LA CLASE
    static FrmConsole console;
    static Thread StatusThread;
    static bool isActive = false;
    #endregion

    //CONSTRUCTORES DE LA CLASE
    #region CONSTRUCTORES DE LA CLASE

    #endregion

    //PROPIEDADES
    #region PROPIEDADES

    #endregion

    //DELEGADOS
    #region DELEGADOS

    #endregion

    //METODOS Y FUNCIONES
    #region METODOS Y FUNCIONES

    public static void Show(string label)
    {
        if (isActive)
        {
            return;
        }

        isActive = true;
        //create the thread with its ThreadStart method
        StatusThread = new Thread(() =>
        {
            try
            {
                console = new FrmConsole(label);
                console.ShowDialog();
                //this call is needed so the thread remains open until the dispatcher is closed
                Dispatcher.Run();
            }
            catch (Exception)
            {
            }
        });

        //run the thread in STA mode to make it work correctly
        StatusThread.SetApartmentState(ApartmentState.STA);
        StatusThread.Priority = ThreadPriority.Normal;
        StatusThread.Start();

    }

    public static void Close()
    {
        isActive = false;
        if (console != null)
        {
            //need to use the dispatcher to call the Close method, because the window is created in another thread, and this method is called by the main thread
            console.Dispatcher.InvokeShutdown();
            console = null;
            StatusThread = null;
        }

        console = null;
    }

    public static void Release()
    {
        isActive = false;
        if (console != null)
        {
            console.Dispatcher.Invoke(console.ActivarCerrar);
        }

    }
    #endregion
}

Ich hoffe, dass dieses Ergebnis sehr nützlich.

Answer 9

diesen Beitrag Check out, war für mich sehr hilfreich. Laden Sie den Code Beispiel:

http://www.codeproject.com/ Artikel / 335.909 / Embedding-a-Console-in-aC-Anwendung

Answer 10

Soweit ich weiß, Console.WriteLine () ist nur für Konsolenanwendungen. Ich denke, das ist Ihr Problem.