Показать консоль в приложении Windows?

Есть ли способ показать консоль в приложении 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());
        }
    }
}

12 ответов

Решение

То, что вы хотите сделать, невозможно в разумном смысле. Был похожий вопрос, так что посмотрите на ответы.

Тогда есть также безумный подход (сайт закрыт - резервная копия доступна здесь), написанный Jeff K.:

Вопрос: Как мне создать приложение, которое может работать в режиме графического интерфейса пользователя (Windows) или в режиме командной строки / консоли?

На первый взгляд, это может показаться простым: вы создаете консольное приложение, добавляете в него форму окна, и все готово. Однако есть проблема:

Проблема: если вы работаете в режиме графического интерфейса пользователя, в конечном итоге вы увидите как окно, так и надоедливую консоль, скрывающуюся в фоновом режиме, и у вас не будет никакого способа ее скрыть.

Похоже, что людям нужно настоящее приложение-амфибия, которое может работать без сбоев в любом режиме.

Если разбить его, то здесь есть четыре варианта использования:

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.

Я выкладываю код, чтобы сделать это, но с оговоркой.

Я на самом деле думаю, что такой подход приведет к гораздо большему количеству неприятностей в будущем, чем оно того стоит. Например, вам нужно иметь два разных интерфейса пользователя - один для графического интерфейса и один для команды / оболочки. Вам нужно будет создать какой-то странный центральный логический движок, который абстрагируется от GUI или командной строки, и это будет странно. Если бы это был я, я бы сделал шаг назад и подумал, как это будет использоваться на практике, и стоит ли этот вид переключения режимов работы. Таким образом, если бы для этого не потребовался какой-то особый случай, я бы сам не использовал этот код, потому что, как только я сталкиваюсь с ситуациями, когда мне нужны вызовы API, чтобы что-то сделать, я, как правило, останавливаюсь и спрашиваю себя: "Я слишком усложняю вещи?".

Тип выхода = Приложение Windows

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

Это немного старый (хорошо, это очень старый), но я делаю то же самое прямо сейчас. Вот очень простое решение, которое работает для меня:

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

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

Самый простой способ - запустить приложение WinForms, перейти в настройки и изменить тип на консольное приложение.

отказ

Есть способ добиться этого, который довольно прост, но я бы не советовал, чтобы это был хороший подход для приложения, которое вы собираетесь показывать другим людям. Но если у вас есть какой-то разработчик, которому нужно одновременно показывать формы консоли и окна, это можно сделать довольно легко.

Этот метод также поддерживает отображение только окна консоли, но не поддерживает отображение только формы Windows - т.е. консоль всегда будет отображаться. Вы можете только взаимодействовать (т.е. получать данные - Console.ReadLine(), Console.Read()) с окном консоли, если вы не показываете окна формы; вывод на консоль - Console.WriteLine() - работает в обоих режимах.

Это предоставляется как есть; нет никаких гарантий, что это не сделает что-то ужасное позже, но это работает.

Шаги проекта

Начните со стандартного консольного приложения.

Отметить Main метод как [STAThread]

Добавьте ссылку в вашем проекте в System.Windows.Forms

Добавьте форму Windows в ваш проект.

Добавьте стандартный стартовый код Windows к вашему Main метод:

Конечный результат

У вас будет приложение, которое отображает консоль и опционально формы Windows.

Образец кода

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 вернул false, родительская консоль отсутствует. Создайте один с 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 лучше после того, как вы уже написали на консоль, и мой ответ лучше, если вы еще не записали на консоль). Важно отметить, что это не работает:

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

Для меня работало то, что я писал отдельное консольное приложение, которое делало то, что я хотел, компилировало его в исполняемый файл, а затем делал 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в соответствии с предыдущими предложениями, поэтому вместо этого я начинаю с консольного приложения. Затем, если консоль не нужна:

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

На самом деле AllocConsole с SetStdHandle в приложении с графическим интерфейсом может быть более безопасным подходом. Уже упоминавшаяся проблема с "захватом консоли" заключается в том, что консоль может вообще не быть окном переднего плана (особенно учитывая приток новых оконных менеджеров в Vista/Windows 7).

Согласно приведенной выше цитате Джеффри Найта, как только я сталкиваюсь с ситуациями, когда мне нужны вызовы API, чтобы что-то сделать, я, как правило, останавливаюсь и спрашиваю себя: "Я слишком усложняю?".

Если нужно иметь некоторый код и запускать его в режиме графического интерфейса Windows или в режиме консоли, рассмотрите возможность перемещения кода, используемого в обоих режимах, в DLL библиотеки кода, а затем наличие приложения Windows Forms, которое использует эту DLL, и консоли приложение, которое использует эту DLL (например, если в Visual Studio у вас теперь есть решение из трех проектов: библиотека с основной частью кода, графический интерфейс только с кодом Win Forms и консоль только с кодом вашей консоли).

В wind32 приложения в консольном режиме - это совершенно другой зверь, чем обычные приложения, принимающие очередь сообщений. Они объявляются и компилируются по-разному. Вы можете создать приложение, которое имеет как консольную часть, так и обычное окно, и скрыть одно или другое. Но подозреваю, что вы найдете все это немного больше работы, чем вы думали.

Создайте приложение Windows Forms. Задайте свойства проекта в приложении, чтобы ввести консольное приложение. Программа откроет консольное окно и покажет формы. Вызовите Console.Writeline из форм или Program.cs для отправки сообщений в окно консоли. Вы можете прокомментировать в Program.cs

// Application.EnableVisualStyles();// Application.SetCompatibleTextRenderingDefault(false);// Application.Run(new Form1());

* /, чтобы избежать использования Form1.

Протестировано на C # и VS2019.

Другие вопросы по тегам