Làm cách nào để hiển thị đầu ra / cửa sổ giao diện điều khiển trong ứng dụng biểu mẫu?

Để bị mắc kẹt ngay lập tức, một ví dụ rất cơ bản:

using System;
using System.Windows.Forms;

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

Nếu tôi biên dịch cái này với các tùy chọn mặc định (sử dụng csc tại dòng lệnh), như mong đợi, nó sẽ biên dịch sang ứng dụng console. Ngoài ra, vì tôi đã nhập System.Windows.Forms, nó cũng sẽ hiển thị một hộp thông báo.

Bây giờ, nếu tôi sử dụng tùy chọn /target:winexe, mà tôi nghĩ giống như chọn Windows Applicationtrong các tùy chọn dự án, như mong đợi, tôi sẽ chỉ thấy Hộp thông báo và không có đầu ra giao diện điều khiển.

(Trong thực tế, thời điểm nó được khởi chạy từ dòng lệnh, tôi có thể đưa ra lệnh tiếp theo trước khi ứng dụng thậm chí đã hoàn thành).

Vì vậy, câu hỏi của tôi là - Tôi biết rằng bạn có thể có "cửa sổ" / hình thức đầu ra từ một ứng dụng bảng điều khiển, nhưng dù sao cũng có thể hiển thị bảng điều khiển từ một ứng dụng Windows?

cái này nên hoạt động

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

Có lẽ điều này là quá đơn giản ...

Tạo một dự án Windows Form ...

Sau đó: Thuộc tính dự án -> Ứng dụng -> Loại đầu ra -> Ứng dụng bảng điều khiển

Sau đó, có thể có Bảng điều khiển và Biểu mẫu chạy cùng nhau, hoạt động với tôi

Nếu bạn không lo lắng về việc mở một bảng điều khiển theo lệnh, bạn có thể đi vào các thuộc tính cho dự án của bạn và thay đổi nó thành Ứng dụng Bảng điều khiển

.

Điều này sẽ vẫn hiển thị biểu mẫu của bạn cũng như bật lên một cửa sổ giao diện điều khiển. Bạn không thể đóng cửa sổ giao diện điều khiển, nhưng nó hoạt động như một trình ghi nhật ký tạm thời tuyệt vời để gỡ lỗi.

Chỉ cần nhớ tắt nó trước khi bạn triển khai chương trình.

Bạn có thể gọi AttachConsolebằng cách sử dụng pinvoke để có cửa sổ giao diện điều khiển được đính kèm với dự án WinForms: http://www.csharp411.com/console-output-from-winforms-application/

Bạn cũng có thể muốn xem xét Log4net ( http://logging.apache.org/log4net/index.html ) để định cấu hình đầu ra nhật ký theo các cấu hình khác nhau.

Điều này làm việc cho tôi, để chuyển đầu ra thành một tập tin. Gọi bàn điều khiển với

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

Thêm mã này vào ứng dụng của bạn.

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

Tôi tìm thấy mã này ở đây: http://www.csharp411.com/console-output-from-winforms-application/ Tôi nghĩ cũng đáng để đăng nó ở đây.

Về cơ bản có hai điều có thể xảy ra ở đây.

Đầu ra giao diện điều khiển Có thể chương trình winforms tự gắn vào cửa sổ giao diện điều khiển đã tạo ra nó (hoặc với một cửa sổ giao diện điều khiển khác, hoặc thực sự với một cửa sổ giao diện điều khiển mới nếu muốn). Sau khi được gắn vào cửa sổ giao diện điều khiển Console.WriteLine () vv hoạt động như mong đợi. Một điều đáng chú ý đối với phương pháp này là chương trình trả lại quyền điều khiển cho cửa sổ giao diện điều khiển ngay lập tức và sau đó tiếp tục ghi vào nó, vì vậy người dùng cũng có thể gõ vào cửa sổ giao diện điều khiển. Bạn có thể sử dụng bắt đầu với tham số / Wait để xử lý điều này tôi nghĩ.

Liên kết để bắt đầu Cú pháp lệnh

Đầu ra giao diện điều khiển được chuyển hướng Đây là khi ai đó chuyển đầu ra từ chương trình của bạn sang một nơi khác, ví dụ.

yourapp> file.txt

Gắn vào cửa sổ bàn điều khiển trong trường hợp này có hiệu quả bỏ qua đường ống. Để thực hiện công việc này, bạn có thể gọi Console.OpenSt ChuẩnOutput () để xử lý luồng mà đầu ra sẽ được dẫn đến. Điều này chỉ hoạt động nếu đầu ra được dẫn, vì vậy nếu bạn muốn xử lý cả hai tình huống bạn cần mở đầu ra tiêu chuẩn và ghi vào nó và gắn vào cửa sổ giao diện điều khiển. Điều này không có nghĩa là đầu ra được gửi đến cửa sổ giao diện điều khiển và tới đường ống nhưng đó là giải pháp tốt nhất tôi có thể tìm thấy. Dưới mã tôi sử dụng để làm điều này.

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

Tạo Ứng dụng Windows Forms và thay đổi loại đầu ra thành Bảng điều khiển.

Nó sẽ dẫn đến cả một giao diện điều khiển và hình thức để mở.

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

Bạn có thể chuyển đổi bất kỳ lúc nào giữa các loại ứng dụng, sang bàn điều khiển hoặc cửa sổ. Vì vậy, bạn sẽ không viết logic đặc biệt để xem thiết bị xuất chuẩn. Ngoài ra, khi chạy ứng dụng trong trình gỡ lỗi, bạn sẽ thấy tất cả các thiết bị xuất chuẩn trong cửa sổ đầu ra. Bạn cũng có thể chỉ cần thêm một điểm dừng và trong các thuộc tính điểm dừng thay đổi "Khi nhấn ...", bạn có thể xuất bất kỳ thông báo và biến nào. Ngoài ra, bạn có thể kiểm tra / bỏ chọn "Tiếp tục thực hiện" và điểm dừng của bạn sẽ trở thành hình vuông. Vì vậy, các thông báo điểm dừng mà không thay đổi bất cứ điều gì trong ứng dụng trong cửa sổ đầu ra gỡ lỗi.

Tại sao không chỉ để nó dưới dạng ứng dụng Window Forms và tạo một biểu mẫu đơn giản để bắt chước Bảng điều khiển. Biểu mẫu có thể được thực hiện để trông giống như Bảng điều khiển màn hình đen và để nó phản hồi trực tiếp với phím bấm. Sau đó, trong tệp chương trình.cs, bạn quyết định xem bạn cần Chạy biểu mẫu chính hay ConsoleForm. Ví dụ, tôi sử dụng cách tiếp cận này để nắm bắt các đối số dòng lệnh trong tệp chương trình.cs. Tôi tạo ConsoleForm, ban đầu ẩn nó, sau đó chuyển các chuỗi dòng lệnh cho hàm AddCommand trong đó, hiển thị các lệnh được phép. Cuối cùng, nếu người dùng đã cho -h hoặc -? lệnh, tôi gọi .Show trên ConsoleForm và khi người dùng nhấn bất kỳ phím nào trên đó, tôi tắt chương trình. Nếu người dùng không cung cấp cho -? lệnh, tôi đóng ConsoleForm ẩn và Chạy biểu mẫu chính.