To jest trochę stare (OK, jest bardzo stare), ale robię dokładnie to samo teraz. Oto bardzo proste rozwiązanie, które działa dla mnie:

    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;

Najprostszym sposobem jest uruchomienie aplikacji WinForms, przejście do ustawień i zmiana typu na aplikację konsolową.

Disclaimer

Istnieje sposób, aby to osiągnąć, który jest dość prosty, ale nie sugerowałbym, że jest to dobre podejście do aplikacji, którą chcesz pokazać innym ludziom. Ale jeśli masz trochę programisty trzeba pokazać konsoli i formularzy windows w tym samym czasie, można to zrobić dość łatwo.

Ta metoda obsługuje również wyświetlanie tylko okna konsoli, ale nie obsługuje wyświetlania tylko formularza Windows - tzn. konsola będzie zawsze wyświetlana. Możesz tylko wchodzić w interakcje (tzn. otrzymywać DANE - Console.ReadLine(), Console.Read()) w oknie konsoli, jeśli nie pokazujesz formularzy windows; wyjście do konsoli - Console.WriteLine() - działa w obu trybach.

Jest to zapewnione tak, jak jest; nie ma gwarancji, że to nie zrobi później czegoś strasznego, ale to działa.

Kroki projektu

Zacznij od standardowej aplikacji konsolowej.

Oznacz metodę Main jako [STAThread]

Dodaj referencję w swoim projekcie do systemu .Okna.Formularze

Dodaj okno formularz do twojego projektu.

Dodaj standardowy kod startowy systemu Windows do metody Main:

Wynik Końcowy

Będziesz miał aplikację, która wyświetla konsolę i opcjonalnie formularze windows.

Przykładowy Kod

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

Wskrzeszenie bardzo starego wątku po raz kolejny, ponieważ żadna z odpowiedzi tutaj nie działa bardzo dobrze dla mnie.

Znalazłem prosty sposób, który wydaje się dość solidny i prosty. U mnie zadziałało. Pomysł:

• Skompiluj swój projekt jako aplikację Windows. Podczas uruchamiania programu może istnieć konsola nadrzędna, ale może nie. Celem jest ponowne użycie istniejącej konsoli, jeśli taka istnieje, lub utworzenie nowej, jeśli nie.
• AttachConsole (-1) będzie szukać konsoli rodzica proces. Jeśli taki jest, to się do niego przywiązuje i jesteś skończony. (Próbowałem tego i działało poprawnie podczas wywoływania mojej aplikacji z cmd)
• Jeśli AttachConsole zwróciło false, nie ma konsoli nadrzędnej. Utwórz go za pomocą AllocConsole.

Przykład:

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

Uwaga : wydaje się, że jeśli spróbujesz napisać do konsoli przed dołączeniem lub przydzieleniu konsoli, takie podejście nie zadziała. Zgaduję, że pierwszy raz dzwonisz do konsoli.Napisz/WriteLine, jeśli tam nie jest już konsolą, a System Windows automatycznie tworzy ukrytą konsolę gdzieś dla Ciebie. (Więc być może odpowiedź Anthony ' ego ShowConsoleWindow jest lepsza po tym, jak już napisałeś do konsoli, a moja odpowiedź jest lepsza, jeśli jeszcze nie napisałeś do konsoli). Ważne jest, aby pamiętać, że to nie działa:

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

Dla mnie to, co zadziałało, to napisać osobno aplikację konsolową, która zrobiła to, co chciałem, skompilować ją do exe, a następnie zrobić Process.Start("MyConsoleapp.exe","Arguments")

Sprawdź ten kod źródłowy. Cały skomentowany kod-służy do tworzenia konsoli w aplikacji Windows. Niezatwierdzone-aby ukryć konsolę w aplikacji konsolowej. Z TUTAJ . (Poprzednio proszę..) 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
    }
}

Właściwie AllocConsole z SetStdHandle w aplikacji GUI może być bezpieczniejszym podejściem. Problem z" console hijacking " już wspomniano, jest to, że konsola może nie być pierwszym oknie w ogóle, (esp. biorąc pod uwagę napływ nowych menedżerów okien w Vista/Windows 7) między innymi.

W wind32 aplikacje w trybie konsolowym są zupełnie inną bestią niż zwykłe aplikacje odbierające kolejki wiadomości. Są one deklarowane i kompilowane w różny sposób. Możesz utworzyć aplikację, która ma zarówno część konsoli, jak i normalne okno i ukryć jedno lub drugie. Ale podejrzewam, że będzie to trochę więcej pracy niż myślałeś.