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

ОТВЕТЫ

Ответ 1

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

Затем также существует безумный подход (сайт вниз - backup доступен здесь.), написанный Джеффри Найт:

Вопрос: Как создать приложение, которое может запускаться в любом графическом интерфейсе? (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.

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

Я на самом деле думаю, что такой подход приведет вас к гораздо более беспокоить дорогу, чем это стоит. Например, вам придется имеют два разных пользовательских интерфейса: один для графического интерфейса и один для команды/ оболочка. Вам нужно будет создать какую-то странную центральную логику движок, который абстрагируется от графического интерфейса и командной строки, и он просто идет чтобы стать странным. Если бы это был я, я бы отступил и подумал о том, как это будет использоваться на практике и будет ли этот режим переключения режимов стоит работы. Таким образом, если для этого не потребовался какой-то специальный случай, я не будет использовать этот код сам, потому что, как только я столкнусь ситуации, когда мне нужны вызовы 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 a new console.");
                    Console.WriteLine("press any key to continue ...");
                    Console.ReadLine();       
                }

                FreeConsole();
            }
        }
    }
}

Ответ 2

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

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

Ответ 3

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

Ответ 4

Отказ

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

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

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

Этапы проекта

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

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

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

Добавьте в свой проект Windows Form.

Добавьте стандартный код запуска 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");
        }
    }
}

Ответ 5

Возобновление очень старой темы еще раз, так как ни один из ответов здесь не работал очень хорошо для меня.

Я нашел простой способ, который кажется довольно прочным и простым. Это сработало для меня. Идея:

  • Скомпилируйте проект как приложение 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 автоматически создает скрытую консоль где-то для вас. (Возможно, ответ Anthony 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());
        }
    }

Ответ 6

Что сработало для меня, так это написать консольное приложение по отдельности, которое делало то, что я хотел, чтобы выполнить его, скомпилировать его в exe, а затем сделать Process.Start("MyConsoleapp.exe","Arguments")

Ответ 7

Проверьте исходный код. Весь прокомментированный код - используется для создания консоли в приложении Windows. Uncommented - скрыть консоль в консольном приложении. Из здесь. (Ранее здесь.) Проект 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
    }
}

Ответ 8

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

Ответ 9

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