Afficher la console dans une application Windows ?

Question

Existe-t-il un moyen d'afficher la console dans une application Windows ?

Je veux faire quelque chose comme ça :

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

Answer 1

Ce que vous voulez faire n'est pas possible de manière saine. Il y avait une question similaire alors regardez les réponses .

Il y a aussi un approche insensée (site en panne - sauvegarde disponible ici. ) écrit par Jeffrey Knight :

Question : Comment puis-je créer une application qui peut fonctionner soit en mode GUI (Windows) ou en ligne de commande / mode console ?

À première vue, cela semble facile : vous créez une application Console à laquelle vous ajoutez un formulaire Windows, et le tour est joué. Cependant, il y a un problème :

Problème : Si vous exécutez en mode GUI, vous vous retrouvez à la fois avec une fenêtre et une console en arrière-plan, et vous n'avez aucun moyen de la cacher. les cacher.

Ce que les gens semblent vouloir, c'est une véritable application amphibie qui peut fonctionner sans problème dans les deux modes.

Si vous le décomposez, il y a en fait quatre cas d'utilisation ici :

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.

Je poste le code pour le faire, mais avec un avertissement.

En fait, je pense que ce genre d'approche vous causera beaucoup plus de problèmes d'ennuis sur la route que ça n'en vaut la peine. Par exemple, vous devrez avoir deux interfaces utilisateur différentes -- une pour l'interface graphique et une pour la commande/le shell. Vous allez devoir construire une sorte de logique centrale étrange logique centrale qui fait abstraction de l'interface graphique et de la ligne de commande. devenir bizarre. Si c'était moi, je prendrais du recul et je réfléchirais à la façon dont ceci sera utilisé dans la pratique, et si ce genre de changement de mode est vaut le coup. Ainsi, à moins qu'un cas spécial ne l'exige, je n'utiliserais pas ce code moi-même. n'utiliserais pas ce code moi-même, car dès que je me trouve dans des situations où j'ai besoin d'appels d'API pour faire quelque chose, j'ai tendance à m'arrêter et à me demander "est-ce que j'en fais trop ? j'ai tendance à m'arrêter et à me demander "est-ce que je complique trop les choses ?".

Type de sortie = Application 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();
            }
        }
    }
}

Answer 2

C'est un peu vieux (OK, c'est TRES vieux), mais je fais exactement la même chose en ce moment. Voici une solution très simple qui fonctionne pour moi :

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

Answer 3

Le moyen le plus simple est de lancer une application WinForms, d'aller dans les paramètres et de changer le type d'application en application console.

Answer 4

Avis de non-responsabilité

Il existe un moyen assez simple d'y parvenir, mais je ne pense pas qu'il s'agisse d'une bonne approche pour une application que vous allez laisser voir à d'autres personnes. Mais si un développeur a besoin de montrer la console et les formulaires Windows en même temps, cela peut être fait assez facilement.

Cette méthode permet également de n'afficher que la fenêtre Console, mais pas de n'afficher que le formulaire Windows - c'est-à-dire que la Console sera toujours affichée. Vous pouvez uniquement interagir (c'est-à-dire recevoir des données - Console.ReadLine() , Console.Read() ) avec la fenêtre de la console si vous ne montrez pas les formulaires Windows ; sortie dans Console - Console.WriteLine() - fonctionne dans les deux modes.

Ceci est fourni tel quel ; il n'y a aucune garantie que cela ne fera pas quelque chose d'horrible plus tard, mais cela fonctionne.

Étapes du projet

Partir d'une norme Application Console .

Marquez le Main comme [STAThread]

Ajoutez une référence dans votre projet à System.Windows.Forms

Ajouter une fenêtre Formulaire à votre projet.

Ajoutez le code de démarrage standard de Windows à votre Main méthode :

Résultat final

Vous disposez d'une application qui affiche la console et éventuellement des formulaires Windows.

Exemple de code

Programme.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");
        }
    }
}

Answer 5

Consultez ce code source. Code entièrement commenté - utilisé pour créer une console dans une application Windows. Non commenté - pour cacher la console dans une application console. À partir de aquí . (Précédemment aquí .) Projet 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
    }
}