How To Create a Console/Window Hybrid Application in C#

Update: if you simply want to pass command line arguments to a Form, see this entry: http://www.rootsilver.com/2008/11/passing-arguments-to-form

This question came up on the Microsoft MSDN C# forum, and I've seen it asked other places as well:

Question: How do I create an application that can run in either GUI (windows) mode or command line / console mode? 

On the surface of it, this would seem easy: you create a Console application, add a windows form to it, and you're off and running.  However, there's a problem:

Problem: If you run in GUI mode, you end up with both a window and a pesky console lurking in the background, and you don't have any way to hide it.   

What people seem to want is a true amphibian application that can run smoothly in either mode.

If you break it down, there are actually four use cases here:

  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 application from existing cmd window, and runs in command mode
  4. User double clicks to start application, and runs in command mode.
I'm posting the code to do this, but with a caveat.

I actually think this sort of approach will run you into a lot more trouble down the road than it's worth.  For example, you'll have to have two different UIs' -- one for the GUI and one for the command / shell.  You're going to have to build some strange central logic engine that abstracts from GUI vs. command line, and it's just going to get weird.  If it were me, I'd step back and think about how this will be used in practice, and whether this sort of mode-switching is worth the work.  Thus, unless some special case called for it, I wouldn't use this code myself, because as soon as I run into situations where I need API calls to get something done, I tend to stop and ask myself "am I overcomplicating things?".  


Output type=Windows Application
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();
            }
        }
    }
}


Categories

,
| Comments (3)TrackBacks (0)

0 TrackBacks

Listed below are links to blogs that reference this entry: How To Create a Console/Window Hybrid Application in C#.

TrackBack URL for this entry: http://www.rootsilver.com/mt-tb.cgi/19

3 Comments

steve said:

Thanks so much for a perfect example of what I have been seeking!! Much more profesionnal than hiding the console window that has a winform.

Perfect!!

Steve

Ye said:

you can try to attach to the parent process console, if it fails, allocate one.

if (! AttachConsole(-1))
{
AllocConsole();
}

Console.WriteLine("aaaa");

FreeConsole();

Tom said:

Actually, this doesn't work correctly. The problem is that, because it is a Windows Application, when you run it in console mode, control returns to the user of the console window before the application completes.

For example, put in a Thread.Sleep(10000) and a Console.WriteLine after the WriteLine saying "hello...". You will see that CMD shows another command prompt and you can type a few commands before the application finally exits.

The best solution to this problem that I've been able to come up with is to split the GUI into a separate EXE, and then have the command-line application use Process.Start to launch the GUI EXE. Then change the main command-line application to a Console Application.

My solution is not very clean, but I can't think of anything simpler.

Leave a comment