มีวิธีแสดงคอนโซลในแอปพลิเคชัน Windows หรือไม่?

ฉันต้องการทำสิ่งนี้:

static class Program
{
    [STAThread]
    static void Main(string[] args) {
        bool consoleMode = Boolean.Parse(args[0]);

        if (consoleMode) {
            Console.WriteLine("consolemode started");
            // ...
        } else {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}

สิ่งที่คุณต้องการทำไม่สามารถทำได้ในทางที่ดี มีคำถามที่คล้ายกันก็เพื่อให้ดูที่ตอบ

นอกจากนี้ยังมีวิธีการที่บ้าคลั่ง (ไซต์ลง - สำรองข้อมูลได้ที่นี่ ) เขียนโดยJeffrey Knight :

คำถาม: ฉันจะสร้างแอปพลิเคชันที่สามารถทำงานในโหมด GUI (windows) หรือโหมดบรรทัดคำสั่ง / คอนโซลได้อย่างไร

บนพื้นผิวของมันสิ่งนี้ดูเหมือนจะง่าย: คุณสร้างแอปพลิเคชันคอนโซลเพิ่มแบบฟอร์มหน้าต่างลงไปจากนั้นคุณก็ออกและทำงาน อย่างไรก็ตามมีปัญหา:

ปัญหา: หากคุณทำงานในโหมด GUI คุณจะพบกับทั้งหน้าต่างและคอนโซลที่น่ารำคาญที่ซุ่มซ่อนอยู่เบื้องหลังและคุณไม่มีทางซ่อนมันได้

สิ่งที่ผู้คนต้องการคือแอปพลิเคชันสัตว์ครึ่งบกครึ่งน้ำที่สามารถทำงานได้อย่างราบรื่นในโหมดใดโหมดหนึ่ง

หากคุณทำลายมันจริงๆมีสี่กรณีการใช้งานที่นี่:

User starts application from existing cmd window, and runs in GUI mode
User double clicks to start application, and runs in GUI mode
User starts application from existing cmd window, and runs in command mode
User double clicks to start application, and runs in command mode.

ฉันกำลังโพสต์รหัสเพื่อทำสิ่งนี้ แต่มีข้อแม้

ที่จริงฉันคิดว่าวิธีการแบบนี้จะทำให้คุณประสบปัญหามากมายกว่าที่ควรจะเป็น ตัวอย่างเช่นคุณจะต้องมี UI สองรายการที่แตกต่างกัน - หนึ่งรายการสำหรับ GUI และอีกหนึ่งรายการสำหรับคำสั่ง / เชลล์ คุณจะต้องสร้างเอ็นจินตรรกะกลางแปลก ๆ ที่แยกจาก GUI เทียบกับบรรทัดคำสั่งและมันจะแปลก ๆ ถ้าเป็นฉันฉันจะย้อนกลับไปคิดว่าจะนำสิ่งนี้ไปใช้ในทางปฏิบัติได้อย่างไรและการสลับโหมดแบบนี้คุ้มค่ากับการทำงานหรือไม่ ดังนั้นเว้นแต่กรณีพิเศษบางอย่างจะเรียกมันฉันจะไม่ใช้รหัสนี้ด้วยตัวเองเพราะทันทีที่ฉันเจอสถานการณ์ที่ฉันต้องเรียก API เพื่อทำบางสิ่งฉันมักจะหยุดและถามตัวเองว่า "ฉันกำลังทำสิ่งต่างๆมากเกินไปหรือเปล่า ".

ประเภทเอาต์พุต = Windows Application

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics;
using Microsoft.Win32;

namespace WindowsApplication
{
    static class Program
    {
        /*
    DEMO CODE ONLY: In general, this approach calls for re-thinking 
    your architecture!
    There are 4 possible ways this can run:
    1) User starts application from existing cmd window, and runs in GUI mode
    2) User double clicks to start application, and runs in GUI mode
    3) User starts applicaiton from existing cmd window, and runs in command mode
    4) User double clicks to start application, and runs in command mode.

    To run in console mode, start a cmd shell and enter:
        c:\path\to\Debug\dir\WindowsApplication.exe console
        To run in gui mode,  EITHER just double click the exe, OR start it from the cmd prompt with:
        c:\path\to\Debug\dir\WindowsApplication.exe (or pass the "gui" argument).
        To start in command mode from a double click, change the default below to "console".
    In practice, I'm not even sure how the console vs gui mode distinction would be made from a
    double click...
        string mode = args.Length > 0 ? args[0] : "console"; //default to console
    */

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool AllocConsole();

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool FreeConsole();

        [DllImport("kernel32", SetLastError = true)]
        static extern bool AttachConsole(int dwProcessId);

        [DllImport("user32.dll")]
        static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll", SetLastError = true)]
        static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

        [STAThread]
        static void Main(string[] args)
        {
            //TODO: better handling of command args, (handle help (--help /?) etc.)
            string mode = args.Length > 0 ? args[0] : "gui"; //default to gui

            if (mode == "gui")
            {
                MessageBox.Show("Welcome to GUI mode");

                Application.EnableVisualStyles();

                Application.SetCompatibleTextRenderingDefault(false);

                Application.Run(new Form1());
            }
            else if (mode == "console")
            {

                //Get a pointer to the forground window.  The idea here is that
                //IF the user is starting our application from an existing console
                //shell, that shell will be the uppermost window.  We'll get it
                //and attach to it
                IntPtr ptr = GetForegroundWindow();

                int  u;

                GetWindowThreadProcessId(ptr, out u);

                Process process = Process.GetProcessById(u);

                if (process.ProcessName == "cmd" )    //Is the uppermost window a cmd process?
                {
                    AttachConsole(process.Id);

                    //we have a console to attach to ..
                    Console.WriteLine("hello. It looks like you started me from an existing console.");
                }
                else
                {
                    //no console AND we're in console mode ... create a new console.

                    AllocConsole();

                    Console.WriteLine(@"hello. It looks like you double clicked me to start
                   AND you want console mode.  Here's a new console.");
                    Console.WriteLine("press any key to continue ...");
                    Console.ReadLine();       
                }

                FreeConsole();
            }
        }
    }
}

นี่มันเก่าไปหน่อย (ตกลงมันเก่ามากแล้ว) แต่ตอนนี้ฉันกำลังทำสิ่งเดียวกัน นี่เป็นวิธีง่ายๆที่เหมาะกับฉัน:

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool AllocConsole();

[DllImport("kernel32.dll")]
static extern IntPtr GetConsoleWindow();

[DllImport("user32.dll")]
static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

const int SW_HIDE = 0;
const int SW_SHOW = 5;

public static void ShowConsoleWindow()
{
    var handle = GetConsoleWindow();

    if (handle == IntPtr.Zero)
    {
        AllocConsole();
    }
    else
    {
        ShowWindow(handle, SW_SHOW);
    }
}

public static void HideConsoleWindow()
{
    var handle = GetConsoleWindow();
    ShowWindow(handle, SW_HIDE);
}

วิธีที่ง่ายที่สุดคือเริ่มแอปพลิเคชัน WinForms ไปที่การตั้งค่าและเปลี่ยนประเภทเป็นแอปพลิเคชันคอนโซล

ข้อจำกัดความรับผิดชอบ

มีวิธีในการบรรลุสิ่งนี้ซึ่งค่อนข้างง่าย แต่ฉันไม่แนะนำว่าเป็นแนวทางที่ดีสำหรับแอปที่คุณจะให้คนอื่นเห็น แต่ถ้าคุณมีนักพัฒนาบางคนต้องการแสดงรูปแบบคอนโซลและหน้าต่างพร้อมกันก็สามารถทำได้อย่างง่ายดาย

วิธีนี้ยังรองรับการแสดงเฉพาะหน้าต่าง Console แต่ไม่รองรับการแสดงเฉพาะ Windows Form นั่นคือ Console จะแสดงเสมอ คุณสามารถโต้ตอบ (เช่นรับข้อมูล - Console.ReadLine(), Console.Read()) กับหน้าต่างคอนโซลเท่านั้นหากคุณไม่แสดงแบบฟอร์ม windows เอาต์พุตไปยังคอนโซล - Console.WriteLine()- ทำงานได้ทั้งสองโหมด

สิ่งนี้มีให้ตามที่เป็นอยู่ ไม่รับประกันว่าสิ่งนี้จะไม่ทำสิ่งที่น่ากลัวในภายหลัง แต่มันได้ผล

ขั้นตอนโครงการ

เริ่มต้นจากมาตรฐานโปรแกรมประยุกต์ของคอนโซล

ทำเครื่องหมายMainวิธีการเป็น[STAThread]

เพิ่มข้อมูลอ้างอิงในโครงการของคุณไปที่System.Windows.Forms

เพิ่มแบบฟอร์ม Windows ในโครงการของคุณ

เพิ่มรหัสเริ่มต้นของ Windows มาตรฐานในMainวิธีการของคุณ:

สิ้นสุดผลลัพธ์

คุณจะมีแอปพลิเคชันที่แสดงรูปแบบคอนโซลและหน้าต่างที่เป็นทางเลือก

ตัวอย่างรหัส

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace ConsoleApplication9 {
    class Program {

        [STAThread]
        static void Main(string[] args) {

            if (args.Length > 0 && args[0] == "console") {
                Console.WriteLine("Hello world!");
                Console.ReadLine();
            }
            else {
                Application.EnableVisualStyles(); 
                Application.SetCompatibleTextRenderingDefault(false); 
                Application.Run(new Form1());
            }
        }
    }
}

Form1.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace ConsoleApplication9 {
    public partial class Form1 : Form {
        public Form1() {
            InitializeComponent();
        }

        private void Form1_Click(object sender, EventArgs e) {
            Console.WriteLine("Clicked");
        }
    }
}

การรื้อฟื้นกระทู้เก่าอีกครั้งเนื่องจากไม่มีคำตอบใดที่ได้ผลดีสำหรับฉัน

ฉันพบวิธีง่ายๆที่ดูแข็งแรงและเรียบง่าย มันได้ผลสำหรับฉัน ความคิด:

• รวบรวมโครงการของคุณเป็นแอปพลิเคชัน Windows อาจมีคอนโซลหลักเมื่อปฏิบัติการของคุณเริ่มทำงาน แต่อาจจะไม่ เป้าหมายคือการนำคอนโซลที่มีอยู่กลับมาใช้ใหม่หากมีอยู่หรือสร้างใหม่หากไม่มี
• AttachConsole (-1) จะมองหาคอนโซลของกระบวนการหลัก ถ้ามีมันก็ยึดติดกับมันเป็นอันเสร็จสิ้น (ฉันลองแล้วและทำงานได้อย่างถูกต้องเมื่อเรียกแอปพลิเคชันของฉันจาก cmd)
• หาก AttachConsole ส่งคืนเป็นเท็จจะไม่มีคอนโซลหลัก สร้างด้วย AllocConsole

ตัวอย่าง:

static class Program
{
    [DllImport( "kernel32.dll", SetLastError = true )]
    static extern bool AllocConsole();

    [DllImport( "kernel32", SetLastError = true )]
    static extern bool AttachConsole( int dwProcessId );

    static void Main(string[] args)
    {
        bool consoleMode = Boolean.Parse(args[0]);
        if (consoleMode)
        {
           if (!AttachConsole(-1))
              AllocConsole();
           Console.WriteLine("consolemode started");
           // ...
        } 
        else
        {
           Application.EnableVisualStyles();
           Application.SetCompatibleTextRenderingDefault(false);
           Application.Run(new Form1());
        }
    }
}

คำเตือน: ดูเหมือนว่าถ้าคุณพยายามเขียนลงคอนโซลก่อนที่จะแนบหรือจัดสรรคอนโซลวิธีนี้จะไม่ได้ผล ฉันเดาว่าเป็นครั้งแรกที่คุณโทรหา Console.Write / WriteLine หากยังไม่มีคอนโซล Windows จะสร้างคอนโซลที่ซ่อนไว้ให้คุณโดยอัตโนมัติ (ดังนั้นคำตอบ ShowConsoleWindow ของ Anthony อาจดีกว่าหลังจากที่คุณเขียนลงคอนโซลแล้วและคำตอบของฉันจะดีกว่าถ้าคุณยังไม่ได้เขียนลงคอนโซล) สิ่งสำคัญที่ควรทราบคือไม่ได้ผล:

static void Main(string[] args)
    {
        Console.WriteLine("Welcome to the program");   //< this ruins everything
        bool consoleMode = Boolean.Parse(args[0]);
        if (consoleMode)
        {
           if (!AttachConsole(-1))
              AllocConsole();
           Console.WriteLine("consolemode started");   //< this doesn't get displayed on the parent console
           // ...
        } 
        else
        {
           Application.EnableVisualStyles();
           Application.SetCompatibleTextRenderingDefault(false);
           Application.Run(new Form1());
        }
    }

สิ่งที่ได้ผลสำหรับฉันคือการเขียนแอปคอนโซลแยกต่างหากซึ่งทำในสิ่งที่ฉันต้องการให้ทำรวบรวมลงใน exe แล้วทำ Process.Start("MyConsoleapp.exe","Arguments")

ตรวจสอบซอร์สโค้ดนี้ โค้ดที่แสดงความคิดเห็นทั้งหมด - ใช้เพื่อสร้างคอนโซลในแอป Windows ไม่ใส่ความคิดเห็น - เพื่อซ่อนคอนโซลในแอปคอนโซล จากที่นี่ . (ก่อนหน้านี้ที่นี่ .) reg2runโครงการ

// Copyright (C) 2005-2015 Alexander Batishchev (abatishchev at gmail.com)

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace Reg2Run
{
    static class ManualConsole
    {
        #region DllImport
        /*
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool AllocConsole();
        */

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool CloseHandle(IntPtr handle);

        /*
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        private static extern IntPtr CreateFile([MarshalAs(UnmanagedType.LPStr)]string fileName, [MarshalAs(UnmanagedType.I4)]int desiredAccess, [MarshalAs(UnmanagedType.I4)]int shareMode, IntPtr securityAttributes, [MarshalAs(UnmanagedType.I4)]int creationDisposition, [MarshalAs(UnmanagedType.I4)]int flagsAndAttributes, IntPtr templateFile);
        */

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool FreeConsole();

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        private static extern IntPtr GetStdHandle([MarshalAs(UnmanagedType.I4)]int nStdHandle);

        /*
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool SetStdHandle(int nStdHandle, IntPtr handle);
        */
        #endregion

        #region Methods
        /*
        public static void Create()
        {
            var ptr = GetStdHandle(-11);
            if (!AllocConsole())
            {
                throw new Win32Exception("AllocConsole");
            }
            ptr = CreateFile("CONOUT$", 0x40000000, 2, IntPtr.Zero, 3, 0, IntPtr.Zero);
            if (!SetStdHandle(-11, ptr))
            {
                throw new Win32Exception("SetStdHandle");
            }
            var newOut = new StreamWriter(Console.OpenStandardOutput());
            newOut.AutoFlush = true;
            Console.SetOut(newOut);
            Console.SetError(newOut);
        }
        */

        public static void Hide()
        {
            var ptr = GetStdHandle(-11);
            if (!CloseHandle(ptr))
            {
                throw new Win32Exception();
            }
            ptr = IntPtr.Zero;
            if (!FreeConsole())
            {
                throw new Win32Exception();
            }
        }
        #endregion
    }
}

จริงๆแล้ว AllocConsole กับ SetStdHandle ในแอปพลิเคชัน GUI อาจเป็นแนวทางที่ปลอดภัยกว่า ปัญหาเกี่ยวกับ "การจี้คอนโซล" ที่กล่าวไปแล้วก็คือคอนโซลอาจไม่ใช่หน้าต่างเบื้องหน้าเลย (โดยเฉพาะเมื่อพิจารณาถึงการไหลเข้าของตัวจัดการหน้าต่างใหม่ใน Vista / Windows 7) เหนือสิ่งอื่นใด

ใน wind32 แอปพลิเคชันโหมดคอนโซลเป็นสัตว์ร้ายที่แตกต่างไปจากแอปพลิเคชันรับข้อความตามปกติอย่างสิ้นเชิง มีการประกาศและรวบรวมแตกต่างกัน คุณอาจสร้างแอปพลิเคชันที่มีทั้งส่วนคอนโซลและหน้าต่างปกติและซ่อนอย่างใดอย่างหนึ่ง แต่สงสัยว่าคุณจะพบว่าสิ่งทั้งหมดทำงานมากกว่าที่คุณคิด

ตามคำกล่าวของ Jeffrey Knight ข้างต้นทันทีที่ฉันพบสถานการณ์ที่ต้องเรียก API เพื่อทำบางสิ่งฉันมักจะหยุดและถามตัวเองว่า "ฉันกำลังทำสิ่งที่ซับซ้อนเกินไปหรือไม่"

หากสิ่งที่ต้องการคือการมีรหัสและเรียกใช้ในโหมด Windows GUI หรือโหมดคอนโซลให้พิจารณาย้ายรหัสที่ใช้ในทั้งสองโหมดไปที่ DLL ไลบรารีโค้ดจากนั้นมีแอปพลิเคชัน Windows Forms ที่ใช้ DLL นั้นและคอนโซล แอปพลิเคชันที่ใช้ DLL นั้น (เช่นถ้าใน Visual Studio ตอนนี้คุณมีโซลูชันสามโปรเจ็กต์: ไลบรารีที่มีโค้ดจำนวนมาก GUI ที่มีเพียงโค้ด Win Forms และคอนโซลที่มีเพียงรหัสคอนโซลของคุณ)

และอีกคำตอบที่ล่าช้า ฉันไม่สามารถรับเอาต์พุตไปยังคอนโซลที่สร้างขึ้นAllocConsoleตามคำแนะนำก่อนหน้านี้ได้ดังนั้นฉันจึงเริ่มต้นด้วยแอปพลิเคชัน Consoleแทน จากนั้นหากไม่จำเป็นต้องใช้คอนโซล:

        [DllImport("kernel32.dll")]
        private static extern IntPtr GetConsoleWindow();

        [DllImport("user32.dll")]
        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        private const int SW_HIDE = 0;
        private const int SW_SHOW = 5;

        [DllImport("user32.dll", SetLastError = true)]
        static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

        public static bool HideConsole()
        {
            var hwnd = GetConsoleWindow();
            GetWindowThreadProcessId(hwnd, out var pid);

            if (pid != Process.GetCurrentProcess().Id) // It's not our console - don't mess with it.
                return false;

            ShowWindow(hwnd, SW_HIDE);

            return true;
        }