Bagaimana cara menampilkan output konsol / jendela di aplikasi formulir?

Untuk langsung terjebak, contoh yang sangat mendasar:

using System;
using System.Windows.Forms;

class test
{ 
    static void Main()
    { 
        Console.WriteLine("test");
        MessageBox.Show("test");
    }
}

Jika saya mengkompilasi ini dengan opsi default (menggunakan csc pada command line), seperti yang diharapkan, itu akan dikompilasi ke aplikasi konsol. Juga, karena saya mengimporSystem.Windows.Forms , itu juga akan menampilkan kotak pesan.

Sekarang, jika saya menggunakan opsi /target:winexe, yang saya pikir sama dengan memilihWindows Application dari dalam opsi proyek, seperti yang diharapkan saya hanya akan melihat Kotak Pesan dan tidak ada output konsol.

(Bahkan, saat diluncurkan dari baris perintah, saya dapat mengeluarkan perintah berikutnya bahkan sebelum aplikasi selesai).

Jadi, pertanyaan saya adalah - Saya tahu Anda dapat memiliki "windows" / membentuk output dari aplikasi konsol, tetapi apakah ada juga untuk menunjukkan konsol dari aplikasi Windows?

ini harus bekerja.

using System.Runtime.InteropServices;

private void Form1_Load(object sender, EventArgs e)
{
    AllocConsole();
}

[DllImport("kernel32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool AllocConsole();

Mungkin ini terlalu sederhana ...

Buat proyek Windows Form ...

Kemudian: Properti Proyek -> Aplikasi -> Jenis Output -> Aplikasi Konsol

Kemudian dapat membuat Konsol dan Formulir berjalan bersama, berfungsi untuk saya

Jika Anda tidak khawatir tentang membuka konsol sesuai perintah, Anda dapat masuk ke properti untuk proyek Anda dan mengubahnya ke Aplikasi Konsol

.

Ini masih akan menunjukkan formulir Anda serta muncul jendela konsol. Anda tidak bisa menutup jendela konsol, tetapi berfungsi sebagai pencatat sementara yang bagus untuk debugging.

Ingatlah untuk mematikannya sebelum Anda menggunakan program ini.

Anda dapat menelepon AttachConsolemenggunakan pinvoke untuk mendapatkan jendela konsol terpasang ke proyek WinForms: http://www.csharp411.com/console-output-from-winforms-application/

Anda mungkin juga ingin mempertimbangkan Log4net ( http://logging.apache.org/log4net/index.html ) untuk mengkonfigurasi keluaran log dalam konfigurasi yang berbeda.

Ini bekerja untuk saya, untuk menyalurkan output ke file. Panggil konsol dengan

cmd / c "C: \ path \ to \ your \ application.exe"> myfile.txt

Tambahkan kode ini ke aplikasi Anda.

    [DllImport("kernel32.dll")]
    static extern bool AttachConsole(UInt32 dwProcessId);
    [DllImport("kernel32.dll")]
    private static extern bool GetFileInformationByHandle(
        SafeFileHandle hFile,
        out BY_HANDLE_FILE_INFORMATION lpFileInformation
        );
    [DllImport("kernel32.dll")]
    private static extern SafeFileHandle GetStdHandle(UInt32 nStdHandle);
    [DllImport("kernel32.dll")]
    private static extern bool SetStdHandle(UInt32 nStdHandle, SafeFileHandle hHandle);
    [DllImport("kernel32.dll")]
    private static extern bool DuplicateHandle(
        IntPtr hSourceProcessHandle,
        SafeFileHandle hSourceHandle,
        IntPtr hTargetProcessHandle,
        out SafeFileHandle lpTargetHandle,
        UInt32 dwDesiredAccess,
        Boolean bInheritHandle,
        UInt32 dwOptions
        );
    private const UInt32 ATTACH_PARENT_PROCESS = 0xFFFFFFFF;
    private const UInt32 STD_OUTPUT_HANDLE = 0xFFFFFFF5;
    private const UInt32 STD_ERROR_HANDLE = 0xFFFFFFF4;
    private const UInt32 DUPLICATE_SAME_ACCESS = 2;
    struct BY_HANDLE_FILE_INFORMATION
    {
        public UInt32 FileAttributes;
        public System.Runtime.InteropServices.ComTypes.FILETIME CreationTime;
        public System.Runtime.InteropServices.ComTypes.FILETIME LastAccessTime;
        public System.Runtime.InteropServices.ComTypes.FILETIME LastWriteTime;
        public UInt32 VolumeSerialNumber;
        public UInt32 FileSizeHigh;
        public UInt32 FileSizeLow;
        public UInt32 NumberOfLinks;
        public UInt32 FileIndexHigh;
        public UInt32 FileIndexLow;
    }
    static void InitConsoleHandles()
    {
        SafeFileHandle hStdOut, hStdErr, hStdOutDup, hStdErrDup;
        BY_HANDLE_FILE_INFORMATION bhfi;
        hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
        hStdErr = GetStdHandle(STD_ERROR_HANDLE);
        // Get current process handle
        IntPtr hProcess = Process.GetCurrentProcess().Handle;
        // Duplicate Stdout handle to save initial value
        DuplicateHandle(hProcess, hStdOut, hProcess, out hStdOutDup,
        0, true, DUPLICATE_SAME_ACCESS);
        // Duplicate Stderr handle to save initial value
        DuplicateHandle(hProcess, hStdErr, hProcess, out hStdErrDup,
        0, true, DUPLICATE_SAME_ACCESS);
        // Attach to console window – this may modify the standard handles
        AttachConsole(ATTACH_PARENT_PROCESS);
        // Adjust the standard handles
        if (GetFileInformationByHandle(GetStdHandle(STD_OUTPUT_HANDLE), out bhfi))
        {
            SetStdHandle(STD_OUTPUT_HANDLE, hStdOutDup);
        }
        else
        {
            SetStdHandle(STD_OUTPUT_HANDLE, hStdOut);
        }
        if (GetFileInformationByHandle(GetStdHandle(STD_ERROR_HANDLE), out bhfi))
        {
            SetStdHandle(STD_ERROR_HANDLE, hStdErrDup);
        }
        else
        {
            SetStdHandle(STD_ERROR_HANDLE, hStdErr);
        }
    }

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main(string[] args)
    {
        // initialize console handles
        InitConsoleHandles();

        if (args.Length != 0)
        {

            if (args[0].Equals("waitfordebugger"))
            {
                MessageBox.Show("Attach the debugger now");
            }
            if (args[0].Equals("version"))
            {
#if DEBUG
                String typeOfBuild = "d";
#else
                String typeOfBuild = "r";
#endif
                String output = typeOfBuild + Assembly.GetExecutingAssembly()
                    .GetName().Version.ToString();
                //Just for the fun of it
                Console.Write(output);
                Console.Beep(4000, 100);
                Console.Beep(2000, 100);
                Console.Beep(1000, 100);
                Console.Beep(8000, 100);
                return;
            }
        }
    }

Saya menemukan kode ini di sini: http://www.csharp411.com/console-output-from-winforms-application/ Saya pikir layak untuk mempostingnya di sini juga.

Pada dasarnya ada dua hal yang bisa terjadi di sini.

Output konsol Adalah mungkin bagi program winforms untuk menempelkan dirinya sendiri ke jendela konsol yang membuatnya (atau ke jendela konsol yang berbeda, atau memang ke jendela konsol baru jika diinginkan). Setelah terpasang ke konsol jendela Console.WriteLine () dll berfungsi seperti yang diharapkan. Salah satu yang perlu dari pendekatan ini adalah bahwa program mengembalikan kontrol ke jendela konsol dengan segera, dan kemudian melanjutkan menulis ke sana, sehingga pengguna juga dapat mengetik di jendela konsol. Anda dapat menggunakan mulai dengan parameter / tunggu untuk menangani ini saya pikir.

Tautan untuk memulai sintaks Perintah

Keluaran konsol yang dialihkan Ini adalah ketika seseorang mengirimkan output dari program Anda ke tempat lain, mis.

aplikasi Anda> file.txt

Melampirkan ke jendela konsol dalam hal ini secara efektif mengabaikan perpipaan. Untuk membuat ini bekerja, Anda dapat memanggil Console.OpenStandardOutput () untuk mendapatkan pegangan ke aliran yang harus dikirim melalui pipa. Ini hanya berfungsi jika output disalurkan, jadi jika Anda ingin menangani kedua skenario, Anda perlu membuka output standar dan menulis ke sana dan melampirkan ke jendela konsol. Ini berarti bahwa output dikirim ke jendela konsol dan ke pipa tetapi solusi terbaik yang bisa saya temukan. Di bawah kode yang saya gunakan untuk melakukan ini.

// This always writes to the parent console window and also to a redirected stdout if there is one.
// It would be better to do the relevant thing (eg write to the redirected file if there is one, otherwise
// write to the console) but it doesn't seem possible.
public class GUIConsoleWriter : IConsoleWriter
{
    [System.Runtime.InteropServices.DllImport("kernel32.dll")]
    private static extern bool AttachConsole(int dwProcessId);

    private const int ATTACH_PARENT_PROCESS = -1;

    StreamWriter _stdOutWriter;

    // this must be called early in the program
    public GUIConsoleWriter()
    {
        // this needs to happen before attachconsole.
        // If the output is not redirected we still get a valid stream but it doesn't appear to write anywhere
        // I guess it probably does write somewhere, but nowhere I can find out about
        var stdout = Console.OpenStandardOutput();
        _stdOutWriter = new StreamWriter(stdout);
        _stdOutWriter.AutoFlush = true;

        AttachConsole(ATTACH_PARENT_PROCESS);
    }

    public void WriteLine(string line)
    {
        _stdOutWriter.WriteLine(line);
        Console.WriteLine(line);
    }
}

Buat Aplikasi Formulir Windows, dan ubah tipe output ke Konsol.

Ini akan menghasilkan konsol dan formulir untuk dibuka.

//From your application set the Console to write to your RichTextkBox 
//object:
Console.SetOut(new RichTextBoxWriter(yourRichTextBox));

//To ensure that your RichTextBox object is scrolled down when its text is 
//changed add this event:
private void yourRichTextBox_TextChanged(object sender, EventArgs e)
{
    yourRichTextBox.SelectionStart = yourRichTextBox.Text.Length;
    yourRichTextBox.ScrollToCaret();
}

public delegate void StringArgReturningVoidDelegate(string text);
public class RichTextBoxWriter : TextWriter
{
    private readonly RichTextBox _richTextBox;
    public RichTextBoxWriter(RichTextBox richTexttbox)
    {
        _richTextBox = richTexttbox;
    }

    public override void Write(char value)
    {
        SetText(value.ToString());
    }

    public override void Write(string value)
    {
        SetText(value);
    }

    public override void WriteLine(char value)
    {
        SetText(value + Environment.NewLine);
    }

    public override void WriteLine(string value)
    {
        SetText(value + Environment.NewLine);
    }

    public override Encoding Encoding => Encoding.ASCII;

    //Write to your UI object in thread safe way:
    private void SetText(string text)
    {
        // InvokeRequired required compares the thread ID of the  
        // calling thread to the thread ID of the creating thread.  
        // If these threads are different, it returns true.  
        if (_richTextBox.InvokeRequired)
        {
            var d = new StringArgReturningVoidDelegate(SetText);
            _richTextBox.Invoke(d, text);
        }
        else
        {
            _richTextBox.Text += text;
        }
    }
}

using System;
using System.Runtime.InteropServices;

namespace SomeProject
{
    class GuiRedirect
    {
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool AttachConsole(int dwProcessId);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr GetStdHandle(StandardHandle nStdHandle);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool SetStdHandle(StandardHandle nStdHandle, IntPtr handle);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern FileType GetFileType(IntPtr handle);

    private enum StandardHandle : uint
    {
        Input = unchecked((uint)-10),
        Output = unchecked((uint)-11),
        Error = unchecked((uint)-12)
    }

    private enum FileType : uint
    {
        Unknown = 0x0000,
        Disk = 0x0001,
        Char = 0x0002,
        Pipe = 0x0003
    }

    private static bool IsRedirected(IntPtr handle)
    {
        FileType fileType = GetFileType(handle);

        return (fileType == FileType.Disk) || (fileType == FileType.Pipe);
    }

    public static void Redirect()
    {
        if (IsRedirected(GetStdHandle(StandardHandle.Output)))
        {
            var initialiseOut = Console.Out;
        }

        bool errorRedirected = IsRedirected(GetStdHandle(StandardHandle.Error));
        if (errorRedirected)
        {
            var initialiseError = Console.Error;
        }

        AttachConsole(-1);

        if (!errorRedirected)
            SetStdHandle(StandardHandle.Error, GetStdHandle(StandardHandle.Output));
    }
}

Anda dapat setiap saat beralih di antara jenis aplikasi, ke konsol atau windows. Jadi, Anda tidak akan menulis logika khusus untuk melihat stdout. Juga, ketika menjalankan aplikasi dalam debugger, Anda akan melihat semua stdout di jendela output. Anda mungkin juga menambahkan breakpoint, dan pada breakpoint properties ubah "When Hit ...", Anda bisa menampilkan pesan, dan variabel apa saja. Anda juga dapat memeriksa / menghapus centang "Lanjutkan eksekusi", dan breakpoint Anda akan menjadi berbentuk persegi. Jadi, pesan breakpoint tanpa mengubah apa pun dalam aplikasi di jendela output debug.

Mengapa tidak tinggalkan saja sebagai aplikasi Window Forms, dan buat formulir sederhana untuk meniru Konsol. Bentuknya dapat dibuat agar terlihat seperti Konsol layar-hitam, dan langsung merespons ke tombol tekan. Kemudian, dalam file program.cs, Anda memutuskan apakah Anda perlu menjalankan formulir utama atau ConsoleForm. Sebagai contoh, saya menggunakan pendekatan ini untuk menangkap argumen baris perintah di file program.cs. Saya membuat ConsoleForm, awalnya menyembunyikannya, lalu meneruskan string baris perintah ke fungsi AddCommand di dalamnya, yang menampilkan perintah yang diizinkan. Akhirnya, jika pengguna memberi -h atau -? perintah, saya memanggil .Show on the ConsoleForm dan ketika pengguna menekan salah satu tombol di atasnya, saya mematikan program. Jika pengguna tidak memberikan -? perintah, saya menutup ConsoleForm tersembunyi dan Jalankan formulir utama.