Konsole in Windows-Anwendung anzeigen?

83

Gibt es eine Möglichkeit, die Konsole in einer Windows-Anwendung anzuzeigen?

Ich möchte so etwas machen:

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

Antworten:

76

Was Sie tun möchten, ist auf vernünftige Weise nicht möglich. Es gab eine ähnliche Frage , schauen Sie sich also die Antworten an .

Dann gibt es noch einen wahnsinnigen Ansatz (Site Down - Backup hier verfügbar ) von Jeffrey Knight :

Frage: Wie erstelle ich eine Anwendung, die entweder im GUI-Modus (Windows) oder im Befehlszeilen- / Konsolenmodus ausgeführt werden kann?

Auf den ersten Blick scheint dies einfach zu sein: Sie erstellen eine Konsolenanwendung, fügen ein Windows-Formular hinzu und können loslegen. Es gibt jedoch ein Problem:

Problem: Wenn Sie im GUI-Modus ausgeführt werden, lauern im Hintergrund sowohl ein Fenster als auch eine lästige Konsole, und Sie haben keine Möglichkeit, sie auszublenden.

Was die Leute zu wollen scheinen, ist eine echte Amphibienanwendung, die in beiden Modi reibungslos ausgeführt werden kann.

Wenn Sie es aufschlüsseln, gibt es hier tatsächlich vier Anwendungsfälle:

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.

Ich poste den Code, um dies zu tun, aber mit einer Einschränkung.

Ich denke tatsächlich, dass diese Art von Ansatz Sie später in viel mehr Schwierigkeiten bringen wird, als es wert ist. Zum Beispiel müssen Sie zwei verschiedene Benutzeroberflächen haben - eine für die GUI und eine für den Befehl / die Shell. Sie müssen eine seltsame zentrale Logik-Engine erstellen, die von der GUI im Vergleich zur Befehlszeile abstrahiert, und es wird nur seltsam. Wenn ich es wäre, würde ich einen Schritt zurücktreten und darüber nachdenken, wie dies in der Praxis angewendet wird und ob diese Art der Modusumschaltung die Arbeit wert ist. Daher würde ich diesen Code nicht selbst verwenden, wenn nicht ein Sonderfall erforderlich wäre, da ich, sobald ich auf Situationen stoße, in denen ich API-Aufrufe benötige, um etwas zu erledigen, dazu neige, anzuhalten und mich zu fragen: "Bin ich zu kompliziert?" ".

Ausgabetyp = Windows-Anwendung

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();
            }
        }
    }
}
Igal Serban
quelle
13
Ich finde es ironisch mit Microsoft und wie es C # -Schnittstellen für die gesamte API erstellen möchte, aber es gibt keine C # -Möglichkeit, um eine so einfache Aufgabe auszuführen.
Ramon Zarazua B.
3
Anstatt davon abhängig zu sein, dass die Konsole das Vordergrundfenster ist, können Sie die übergeordnete Prozess-ID des aktuellen Prozesses mithilfe von winapi abrufen: stackoverflow.com/a/3346055/855432
ghord
2
Zum Zeitpunkt des Schreibens ist eine Sicherungskopie des Artikels hier verfügbar. Web.archive.org/web/20111227234507/http://www.rootsilver.com/…
Andrew Savinykh
2
Hallo! Ich fand heraus, dass, wenn ich diese Lösung von einer Shell wie Far aus ausführe, nc eine neue Konsole erstellt wird. Wenn ich wie cmd an Far Console anhefte, funktioniert das falsch. Ich empfehle, ConsoleApplication zu erstellen. Wenn eine grafische Benutzeroberfläche erforderlich ist, führen Sie FreeConsole () aus. Ausgezeichneter Artikel! Vielen Dank!
Maxim Vasiliev
6
Ich würde empfehlen, AttachConsolemit -1(dem Wert der API-Konstante ATTACH_PARENT_PROCESS) aufzurufen, anstatt zu hoffen, dass das Vordergrundfenster das richtige Befehlsfenster zum Schreiben ist.
Jon Hanna
68

Das ist ein bisschen alt (OK, es ist SEHR alt), aber ich mache genau das Gleiche im Moment. Hier ist eine sehr einfache Lösung, die für mich funktioniert:

[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);
}
Anthony
quelle
5
Wenn Sie dies in einem Cmd-Fenster ausführen, wird ein weiteres Konsolenfenster geöffnet, das im automatisierten Prozess, der die Konsolenausgabe erfassen muss, nicht wünschenswert ist.
AaA
Am Ende habe ich den bereitgestellten Code verwendet, aber eine gemeinsam genutzte InitConsole () - Funktion hinzugefügt, um den AllocConsole () - Teil auszuführen, wenn das Handle intptr.zero ist. Als ich ShowConsoleWindow benutzte und es unmittelbar danach druckte, funktionierte es nicht. Das Zuweisen der Konsole beim Start der Anwendung und die Verwendung von ShowConsoleWindow hat funktioniert. Davon abgesehen ist das perfekt für mich. Vielen Dank ..
Sage Pourpre
Console.WriteLineProtokolle werden nicht angezeigt in dem Fall, der von cmd mit args gestartet wurde
Mohammad Ali
Vergiss nichtusing System.Runtime.InteropServices;
Darren Griffith
19

Am einfachsten ist es, eine WinForms-Anwendung zu starten, die Einstellungen aufzurufen und den Typ in eine Konsolenanwendung zu ändern.

ICR
quelle
1
Anwendung -> Ausgabetyp: Konsolenanwendung. Hab es für mich getan!
Lodewijk
Das hat super geklappt. Hoffentlich bringt es nichts anderes durcheinander. Danke und +1.
Deathismyfriend
1
Das Starten der Anwendung durch Doppelklicken öffnet ein cmd-Fenster
Mohammad Ali
13

Haftungsausschluss

Es gibt einen Weg, dies zu erreichen, der recht einfach ist, aber ich würde nicht vorschlagen, dass dies ein guter Ansatz für eine App ist, die Sie anderen Menschen zeigen lassen werden. Wenn Sie jedoch einige Entwickler hatten, die die Konsolen- und Windows-Formulare gleichzeitig anzeigen müssen, können Sie dies ganz einfach tun.

Diese Methode unterstützt auch das Anzeigen nur des Konsolenfensters, jedoch nicht das Anzeigen nur des Windows Form - dh die Konsole wird immer angezeigt. Sie können mit dem Konsolenfenster nur interagieren (dh Daten empfangen - Console.ReadLine(), Console.Read()), wenn Sie die Windows-Formulare nicht anzeigen. Ausgabe an die Konsole - Console.WriteLine()- funktioniert in beiden Modi.

Dies wird so bereitgestellt, wie es ist; Keine Garantie, dass dies später nichts Schreckliches bewirkt, aber es funktioniert.

Projektschritte

Starten Sie von einer Standard- Konsolenanwendung .

Markieren Sie die MainMethode als[STAThread]

Fügen Sie in Ihrem Projekt eine Referenz zu System.Windows.Forms hinzu

Fügen Sie Ihrem Projekt ein Windows Form hinzu .

Fügen Sie Ihrer MainMethode den Standard-Windows- Startcode hinzu:

Endresultat

Sie haben eine Anwendung, die die Konsolen- und optional Windows-Formulare anzeigt.

Beispielcode

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");
        }
    }
}
Sam Meldrum
quelle
schöner Code hier. aber wie deaktivierst du das Anzeigen der Konsole, wenn du verkaufen oder bereitstellen willst oder etwas anderes?
R4ccoon
@ r4ccoon - du kannst nicht. Sie können Ihren gesamten Code jedoch problemlos in eine normale Windows-App verschieben.
Sam Meldrum
IMHO ist es einfacher, den gleichen Effekt zu erzielen, wenn Sie wie gewohnt ein Windows Forms-Projekt erstellen, dann im Projektmappen-Explorer -> Eigenschaften mit der rechten Maustaste darauf klicken und den Ausgabetyp in Konsolenanwendung ändern. (Bearbeiten: Jetzt habe ich erkannt, dass es im Grunde die Antwort von ICR ist)
Kamilk
Schön Schritt für Schritt Antwort
AminM
9

Wieder einen sehr alten Thread wiederbeleben, da keine der Antworten hier für mich sehr gut funktioniert hat.

Ich habe einen einfachen Weg gefunden, der ziemlich robust und einfach erscheint. Es hat bei mir funktioniert. Die Idee:

  • Kompilieren Sie Ihr Projekt als Windows-Anwendung. Möglicherweise gibt es eine übergeordnete Konsole, wenn Ihre ausführbare Datei gestartet wird, aber möglicherweise nicht. Ziel ist es, die vorhandene Konsole wiederzuverwenden, falls vorhanden, oder eine neue zu erstellen, wenn nicht.
  • AttachConsole (-1) sucht nach der Konsole des übergeordneten Prozesses. Wenn es eine gibt, hängt sie daran und Sie sind fertig. (Ich habe es versucht und es hat richtig funktioniert, als ich meine Anwendung von cmd aufgerufen habe.)
  • Wenn AttachConsole false zurückgibt, gibt es keine übergeordnete Konsole. Erstellen Sie eine mit AllocConsole.

Beispiel:

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

Ein Wort der Vorsicht: Wenn Sie versuchen, vor dem Anhängen oder Zuweisen einer Konsole auf die Konsole zu schreiben, funktioniert dieser Ansatz anscheinend nicht. Ich vermute, dass Sie Console.Write / WriteLine zum ersten Mal aufrufen. Wenn noch keine Konsole vorhanden ist, erstellt Windows automatisch eine versteckte Konsole für Sie. (Vielleicht ist Anthonys ShowConsoleWindow-Antwort besser, nachdem Sie bereits an die Konsole geschrieben haben, und meine Antwort ist besser, wenn Sie noch nicht an die Konsole geschrieben haben). Wichtig ist, dass dies nicht funktioniert:

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());
        }
    }
Kevin Holt
quelle
Vielen Dank, dass Sie Beispielcode freigegeben haben. Ich habe es versucht und festgestellt, dass es funktioniert, aber mit Einschränkungen. Es gibt keine Umleitung der Konsolenausgabe (kann durch zusätzlichen Quellcode behoben werden). Der Hauptnachteil ist jedoch, dass die Kontrolle sofort an die Konsole zurückgegeben wird. Zum Beispiel, wenn ich tippe \bin\Debug>shareCheck.exe /once und die Eingabetaste drücke, wird angezeigt und dann beginnt die Konsole mit der Ausgabe: \bin\Debug>hello. It looks like you started me from an existing console.und wenn das Programm endet, gibt es keine Eingabeaufforderung, so dass die letzte Ausgabezeile und der leere Bildschirm ein bisschen verrückt sind
oleksa
Dank Kevin für das Wort der Vorsicht - Ich habe Probleme mit der in diesem SO Post vorgeschlagen Ansätze und ich scheinen die „versteckte Konsole“ selbst zu bekommen , obwohl ich nicht , bevor passiert jede Konsole ausgegeben haben ... Es stellte sich heraus , dass Das Fenster "Ausgabe" in Visual Studio ist die versteckte Konsole, wenn Ihre App mit angeschlossenem Debugger ausgeführt wird! Erwähnenswert ... (also funktionierte mein Programm beim Umschalten auf ohne Debugger, dh Strg-F5)
Per Lundberg
3

Was für mich funktioniert hat, war, eine Konsolen-App separat zu schreiben, die das tat, was ich wollte, sie zu einer Exe zu kompilieren und dann zu tun Process.Start("MyConsoleapp.exe","Arguments")

Ian
quelle
1
Das ist die Rasiermesserversion von Occam. Nicht herausfordernd genug: P
Michael Hoffmann
3

Überprüfen Sie diesen Quellcode. Alle kommentierten Codes - werden zum Erstellen einer Konsole in einer Windows-App verwendet. Nicht kommentiert - um die Konsole in einer Konsolen-App auszublenden. Von hier aus . (Zuvor hier .) Projekt 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
    }
}
abatishchev
quelle
1

Tatsächlich könnte AllocConsole mit SetStdHandle in einer GUI-Anwendung ein sicherer Ansatz sein. Das Problem bei der bereits erwähnten "Konsolenentführung" besteht darin, dass die Konsole möglicherweise überhaupt kein Vordergrundfenster ist (insbesondere unter Berücksichtigung des Zustroms neuer Fenstermanager in Vista / Windows 7).

EFraim
quelle
0

In wind32 sind Anwendungen im Konsolenmodus eine völlig andere Sache als die üblichen Anwendungen, die Nachrichtenwarteschlangen empfangen. Sie werden unterschiedlich deklariert und kompiliert. Sie können eine Anwendung erstellen, die sowohl einen Konsolenteil als auch ein normales Fenster enthält, und das eine oder andere ausblenden. Aber vermuten Sie, dass Sie das Ganze ein bisschen mehr Arbeit finden werden, als Sie gedacht haben.

Joe Seelenbringer
quelle
Wind32 klingt wie etwas, das in ein Meteorologieforum gehört, aber wenn Sie Win32 meinen, beachten Sie, dass wir Nachrichtenschleifen in Konsolenprogrammen erstellen können, wie in PostThreadMessage to Console Application .
user34660
0

Gemäß dem obigen Zitat von Jeffrey Knight neige ich dazu, anzuhalten und mich zu fragen, ob ich Dinge überkompliziere, sobald ich auf Situationen stoße, in denen ich API-Aufrufe benötige, um etwas zu erledigen.

Wenn Sie Code haben und ihn im Windows-GUI-Modus oder im Konsolenmodus ausführen möchten, sollten Sie den in beiden Modi verwendeten Code in eine Codebibliotheks-DLL verschieben und dann eine Windows Forms-Anwendung, die diese DLL verwendet, und eine Konsole verwenden Anwendung, die diese DLL verwendet (dh wenn Sie in Visual Studio jetzt eine Lösung mit drei Projekten haben: Bibliothek mit dem Großteil des Codes, GUI mit nur dem Win Forms-Code und Konsole mit nur Ihrem Konsolencode.)

Jinlye
quelle
0

Und noch eine verspätete Antwort. Ich konnte keine Ausgabe an die Konsole erhalten, die AllocConsolegemäß früheren Vorschlägen erstellt wurde. Stattdessen beginne ich mit der Konsolenanwendung . Wenn die Konsole dann nicht benötigt wird:

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