Як відобразити консольний вихід / вікно у програмі форм?

Щоб застрягти прямо, дуже базовий приклад:

using System;
using System.Windows.Forms;

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

Якщо я компілюю це з параметрами за замовчуванням (використовуючи csc в командному рядку), як очікувалося, він буде компілюватися в консольний додаток. Крім того, оскільки я імпортував System.Windows.Forms, він також відображатиме вікно повідомлень.

Тепер, якщо я використовую параметр /target:winexe, який, на мою думку, є таким самим, як і вибір Windows Applicationу межах варіантів проекту, як і очікувалося, я побачу лише поле повідомлень і відсутність консольного виходу.

(Насправді, в момент його запуску з командного рядка я можу видавати наступну команду ще до того, як додаток навіть завершиться).

Отже, моє питання - я знаю, що ви можете мати "windows" / форми виводу з консольного додатка, але чи все-таки можна показати консоль із програми Windows?

це має працювати.

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

Можливо, це занадто спрощено ...

Створення проекту Windows Form ...

Потім: Властивості проекту -> Застосування -> Тип виводу -> Приклад консолі

Тоді консолі та форми можуть працювати разом, працює для мене

Якщо ви не турбуєтесь про відкриття консолі в команді, ви можете перейти до властивостей свого проекту та змінити його на консольну програму

.

Це все одно покаже вашу форму, а також спливе вікно консолі. Ви не можете закрити вікно консолі, але воно працює як відмінний тимчасовий реєстратор для налагодження.

Просто пам’ятайте, щоб вимкнути його перед тим, як розгорнути програму.

Ви можете зателефонувати AttachConsoleза допомогою pinvoke, щоб отримати вікно консолі, приєднане до проекту WinForms: http://www.csharp411.com/console-output-from-winforms-application/

Ви також можете розглянути Log4net ( http://logging.apache.org/log4net/index.html ) для налаштування виводу журналу в різних конфігураціях.

Це працювало для мене, щоб передавати вихід у файл. Телефонуйте на консоль за допомогою

cmd / c "C: \ шлях \ до \ ваш \ application.exe"> myfile.txt

Додайте цей код у свою програму.

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

Я знайшов цей код тут: http://www.csharp411.com/console-output-from-winforms-application/ Я вважав, що це гідно, щоб також розмістити його тут.

Тут в основному можуть статися дві речі.

Вихід з консолі Програма winforms може приєднатись до вікна консолі, яке її створило (або до іншого вікна консолі, або, за бажанням, до нового вікна консолі). Після приєднання до вікна консолі Console.WriteLine () тощо працює так, як очікувалося. Одним із причин такого підходу є те, що програма негайно повертає контроль у вікно консолі, а потім продовжує писати до нього, щоб користувач також міг набрати у вікно консолі. Ви можете використовувати старт з параметром / wait, щоб впоратися з цим, я думаю.

Посилання для запуску синтаксису команд

Перенаправлений вихід консолі Це коли хтось передає вихід з вашої програми десь в іншому місці, наприклад.

yourapp> file.txt

Приєднання до вікна консолі в цьому випадку ефективно ігнорує трубопроводи. Щоб зробити цю роботу, ви можете зателефонувати на Console.OpenStandardOutput (), щоб отримати ручку до потоку, до якого повинен бути переданий вихід. Це працює лише в тому випадку, якщо вихід є конвеєрним, тому якщо ви хочете обробити обидва сценарії, вам потрібно відкрити стандартний вихід і записати його та приєднати до вікна консолі. Це означає, що вихід направляється у вікно консолі та на трубу, але найкраще рішення, яке я міг знайти. Нижче коду, який я використовую для цього.

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

Створіть додаток Windows Forms та змініть тип виводу на Console.

Це призведе до відкриття консолі та форми .

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

Ви можете будь-який час перемикатися між типом програм, на консолі чи вікна. Отже, ви не будете писати спеціальної логіки, щоб побачити stdout. Крім того, під час запуску програми у відладчику ви побачите всю stdout у вихідному вікні. Ви також можете просто додати точку розриву, а у властивості точки перерви змінити "Коли потрапляє ...", ви можете виводити будь-які повідомлення та змінні. Також ви можете встановити / зняти прапорець "Продовжити виконання", і ваша точка розриву набуде квадратної форми. Отже, повідомлення точки перерви, не змінюючи нічого в програмі у вікні виводу налагодження.

Чому б просто не залишити його як додаток Window Forms, а створити просту форму для імітації консолі. Форма може бути такою, що виглядає як чорно екранована консоль, і відповісти їй безпосередньо на натискання клавіш. Потім у файлі program.cs ви вирішите, чи потрібно запускати основну форму чи ConsoleForm. Наприклад, я використовую такий підхід для збору аргументів командного рядка у файл program.cs. Я створюю ConsoleForm, спочатку приховую його, потім передаю рядки командного рядка функції AddCommand в ньому, яка відображає дозволені команди. Нарешті, якщо користувач дав -h або -? команду, я закликаю .Show на ConsoleForm і коли користувач натискає будь-яку клавішу на ньому, я вимикаю програму. Якщо користувач не дає -? команду, я закриваю прихований ConsoleForm і запускаю основну форму.