Afficher la Console en Application de Windows?

Ce que vous voulez faire n'est pas possible dans un façon saine. Il y a une question similaire alors regardez les réponses.

Puis il y a aussi un fou approche (site sauvegarde disponible ici.) écrit par Jeffrey Chevalier:

Question: Comment puis-je créer une application qui peut s'exécuter en mode GUI
(windows) ou en mode ligne de commande /mode console?

Sur la surface, cela semble simple: vous créez une Console
l'application, ajouter un formulaire windows, et vous êtes opérationnel.
Cependant, il y a un problème:

Problème: Si vous exécutez en mode graphique, vous vous retrouvez avec une fenêtre et une
satanés console tapi dans le fond, et vous n'avez pas de moyen de
le cacher.

Ce que les gens semblent vouloir, c'est un vrai amphibiens application qui peut fonctionner
en douceur, dans les deux modes.

Si vous le briser, il ya 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 faire cela, mais avec une mise en garde.

Je pense en fait que ce type de démarche va vous courir beaucoup plus
ennuis en bas de la route que ce qu'il vaut. Par exemple, vous aurez à
deux différents Isu', une pour l'interface graphique et l'autre pour la commande /
shell. Vous allez devoir bâtir une étrange centrale de la logique
moteur de résumés à partir de GUI vs ligne de commande, et il va juste
pour obtenir bizarre. Si c'était moi, je serais pas en arrière et de réfléchir sur la façon dont cette
seront utilisés dans la pratique, et que ce type de mode de commutation est
intéressant le travail. Ainsi, sauf quelques cas spécial appelé pour elle, je
ne pas utiliser ce code moi-même, parce que dès que je tombe sur
les situations où j'ai besoin des appels API pour obtenir quelque chose, j'ai tendance à
arrêter et de me demander "suis-je de compliquer à l'excès les choses?".

De sortie type=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();
}
}
}
}

Façon la plus simple est de démarrer une application WinForms, allez à paramètres et de modifier le type d'une application console.

Ressusciter un très vieux thread encore une fois, étant donné qu'aucune des réponses ici très bien fonctionné pour moi.

J'ai trouvé un moyen simple qui semble assez robuste et simple. Il a travaillé pour moi. L'idée:

• Compiler votre projet comme une Application Windows. Il pourrait être un parent de la console lors de votre exécutable démarre, mais peut-être pas. L'objectif est de ré-utiliser la console existante, s'il en existe, ou en créer un nouveau si ce n'.
• AttachConsole(-1) va chercher la console du processus parent. Si il y en a un, il s'attache à elle et vous avez terminé. (J'ai essayé et cela a fonctionné correctement lors de l'appel de ma demande de cmd)
• Si AttachConsole retourné false, il n'est pas parent de la console. Créer un avec AllocConsole.

Exemple:

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

Un mot de prudence : il semble que si vous essayez d'écrire sur la console avant de fixer ou de allocing une console, cette approche ne fonctionne pas. Ma conjecture est la première fois que vous appelez de la Console.Écrire/WriteLine, si il n'y a pas déjà une console Windows crée automatiquement une console masqué quelque part pour vous. (Donc peut-être d'Anthony ShowConsoleWindow réponse est mieux après que vous avez déjà écrit à la console, et ma réponse est mieux si vous n'avez pas encore écrit de la console). La chose importante à noter est que cela ne fonctionne pas:

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

Vérifier cette source code. Tous les code commenté – utilisé pour créer une console dans une application Windows. Sans commentaire – pour masquer la console dans une application console. De ici. (Précédemment ici.) 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
}
}

Dans wind32, en mode console applications sont complètement bête différente de l'habituel message à la file d'attente de réception des demandes. Ils sont déclarées et compiler différemment. Vous pouvez créer une application qui possède à la fois une partie de la console et fenêtre normale et se cacher l'un ou l'autre. Mais le suspect, vous trouverez le tout un peu plus de travail que vous avez pensé.