Using AttachConsole, user must hit enter to get regular command line

Question

I have a progaram that can be ran both as a winform, or from command line. If it is invoked from a command line I call AttachConsole(-1) to attach to parent console.

However, after my program ends, the user must hit enter to get back the standard command prompt ("c:\>"). is there a way to avoid that need?

Thanks. I could wrap it in a cmd file to avoid that issue, but I would like to do it from my exe.

Answer 1

Try adding this line just before your exe exits...

System.Windows.Forms.SendKeys.SendWait("{ENTER}");

Bit of a hack, but best I could find when I encountered that problem.

Answer 2

Here is the safest hack that solves the Enter key problem regardless of whether the console window is in the foreground, background, or minimized. You can even run it in multiple console windows.

using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace WindowsAndConsoleApp
{
  static class Program
  {
    const uint WM_CHAR = 0x0102;
    const int VK_ENTER = 0x0D;

    [DllImport("kernel32.dll")]
    static extern bool AttachConsole(int dwProcessId);
    private const int ATTACH_PARENT_PROCESS = -1;

    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool FreeConsole();

    [DllImport("kernel32.dll")]
    static extern IntPtr GetConsoleWindow();

    [DllImport("user32.dll")]
    static extern int SendMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [STAThread]
    static void Main(string[] args)
    {
        if (args.Length > 0)
        {
            // Do this first.
            AttachConsole(ATTACH_PARENT_PROCESS);

            Console.Title = "Console Window - Enter Key Test";
            Console.WriteLine("Getting the handle of the currently executing console window...");
            IntPtr cw = GetConsoleWindow();
            Console.WriteLine($"Console handle: {cw.ToInt32()}");
            Console.WriteLine("\nPut some windows in from of this one...");
            Thread.Sleep(5000);
            Console.WriteLine("Take your time...");
            Thread.Sleep(5000);
            Console.WriteLine("Sending the Enter key now...");

            // Send the Enter key to the console window no matter where it is.
            SendMessage(cw, WM_CHAR, (IntPtr)VK_ENTER, IntPtr.Zero);

            // Do this last.
            FreeConsole();
        }
        else
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());
        }
    }
  }
}

Answer 3

Rob L's approach is somewhat dangerous as it will send an Enter to the active window. A better approach is to actual send the Enter to the correct process (console).

here is how

    internal static class NativeMethods
    {
        [DllImport("kernel32.dll", SetLastError = true)]
        internal static extern bool AllocConsole();

        [DllImport("kernel32.dll", SetLastError = true)]
        internal static extern bool FreeConsole();

        [DllImport("kernel32", SetLastError = true)]
        internal static extern bool AttachConsole(int dwProcessId);

        [DllImport("user32.dll")]
        internal static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll", SetLastError = true)]
        internal static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

        [DllImport("User32.Dll", EntryPoint = "PostMessageA")]
        internal static extern bool PostMessage(IntPtr hWnd, uint msg, int wParam, int lParam);

        internal const int VK_RETURN = 0x0D;
        internal const int WM_KEYDOWN = 0x100;
    }

--snip--

            bool attached = false;

            // Get uppermost window process
            IntPtr ptr = NativeMethods.GetForegroundWindow();
            int u;
            NativeMethods.GetWindowThreadProcessId(ptr, out u);
            Process process = Process.GetProcessById(u);

            if (string.Compare(process.ProcessName, "cmd", StringComparison.InvariantCultureIgnoreCase) == 0)
            {
                // attach to the current active console
                NativeMethods.AttachConsole(process.Id);
                attached = true;
            }
            else
            {
                // create new console
                NativeMethods.AllocConsole();
            }

            Console.Write("your output");

            NativeMethods.FreeConsole();

            if (attached)
            {
                var hWnd = process.MainWindowHandle;
                NativeMethods.PostMessage(hWnd, NativeMethods.WM_KEYDOWN, NativeMethods.VK_RETURN, 0);
            }

This solution is build upon the code that is found here:

http://www.jankowskimichal.pl/en/2011/12/wpf-hybrid-application-with-parameters/

Answer 4

It's late to the party and there have been many suggestions over the years, but as I recently just solved this issue myself by stitching together a bunch of information from various posts, I thought I'd post the solution here since it has the most relevant title.

This solution works without using the Enter key or simulating a key press. The only thing I couldn't completely solve is intercepting the Enter from the parent console when your application starts. I think this is impossible because it happens before you get a chance to intercept it; however, there is a reasonable quasi-workaround.

Before diving into the code, here's the sequence of things we need to do:

1. Attach to the parent console
2. Capture the text of the current prompt output by the parent console
3. Clear the parent console's prompt by overwriting it with spaces (not sure it's possible to otherwise prevent this from happening)
4. Interact with the console as normal
5. Restore parent console's previous prompt by writing what we captured in #2

This is what it would look like in use:

using System;
using System.Windows.Forms;

public static void Main(string[] args)
{
    if (args.Length > 0)
    {
        using (new ConsoleScope())
        {
            Console.WriteLine("I now own the console");
            Console.WriteLine("MUA HA HA HA HA HA!!!");
        }
    }
    else
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());
    }
}

... and now for the code. It's more than I'd like, but this is as succinct as I could make it for a post. May this help others attempting the same thing. Enjoy!

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;

public sealed class ConsoleScope : IDisposable
{
    const int ATTACH_PARENT_PROCESS = -1;
    const int STD_OUTPUT_HANDLE = -11;
    readonly bool createdNewConsole;
    readonly string prompt;
    bool disposed;

    public ConsoleScope()
    {
        if (AttachParentConsole())
        {
            prompt = CaptureParentConsoleCurrentPrompt();
        }
        else
        {
            AllocConsole();
            createdNewConsole = true;
        }
    }

    ~ConsoleScope() => CleanUp();

    public void Dispose()
    {
        CleanUp();
        GC.SuppressFinalize(this);
    }

    static string CaptureParentConsoleCurrentPrompt()
    {
        var line = (short)Console.CursorTop;
        var length = (short)Console.CursorLeft;
        var noPrompt = line == 0 && length == 0;

        if (noPrompt)
        {
            return default;
        }

        return ReadCurrentLineFromParentConsoleBuffer(line, length);
    }

    static string ReadCurrentLineFromParentConsoleBuffer(short line, short length)
    {
        var itemSize = Marshal.SizeOf(typeof(CHAR_INFO));
        var buffer = Marshal.AllocHGlobal(length * itemSize);
        var encoding = Console.OutputEncoding;
        var text = new StringBuilder(capacity: length + 1);
        var coordinates = default(COORD);
        var textRegion = new SMALL_RECT
        {
            Left = 0,
            Top = line,
            Right = (short)(length - 1),
            Bottom = line,
        };
        var bufferSize = new COORD
        {
            X = length,
            Y = 1,
        };

        try
        {
            if (!ReadConsoleOutput(GetStdOutputHandle(), buffer, bufferSize, coordinates, ref textRegion))
            {
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
            }

            var array = buffer;

            for (var i = 0; i < length; i++)
            {
                var info = Marshal.PtrToStructure<CHAR_INFO>(array);
                var chars = encoding.GetChars(info.CharData);

                text.Append(chars[0]);
                array += itemSize;
            }
        }
        finally
        {
            Marshal.FreeHGlobal(buffer);
        }

        // now that we've captured the current prompt, overwrite it with spaces
        // so that things start where the parent left off at
        Console.SetCursorPosition(0, line);
        Console.Write(new string(' ', length));
        Console.SetCursorPosition(0, line - 1);

        return text.ToString();
    }

    void CleanUp()
    {
        if (disposed)
        {
            return;
        }

        disposed = true;
        RestoreParentConsolePrompt();

        if (createdNewConsole)
        {
            FreeConsole();
        }
    }

    void RestoreParentConsolePrompt()
    {
        var text = prompt;

        if (!string.IsNullOrEmpty(text))
        {
            // this assumes the last output from your application used
            // Console.WriteLine or otherwise output a CRLF. if it didn't,
            // you may need to add an extra line here
            Console.Write(text);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    struct CHAR_INFO
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] CharData;
        public short Attributes;
    }

    [StructLayout(LayoutKind.Sequential)]
    struct COORD
    {
        public short X;
        public short Y;
    }

    [StructLayout(LayoutKind.Sequential)]
    struct SMALL_RECT
    {
        public short Left;
        public short Top;
        public short Right;
        public short Bottom;
    }

    // REF: https://learn.microsoft.com/en-us/windows/console/allocconsole
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool AllocConsole();

    // REF: https://learn.microsoft.com/en-us/windows/console/attachconsole
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool AttachConsole(int dwProcessId);

    // REF: https://learn.microsoft.com/en-us/windows/console/freeconsole
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool FreeConsole();

    static bool AttachParentConsole() => AttachConsole(ATTACH_PARENT_PROCESS);

    // REF: https://learn.microsoft.com/en-us/windows/console/readconsoleoutput
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool ReadConsoleOutput(IntPtr hConsoleOutput, IntPtr lpBuffer, COORD dwBufferSize, COORD dwBufferCoord, ref SMALL_RECT lpReadRegion);

    [DllImport("kernel32.dll", SetLastError = true)]
    static extern IntPtr GetStdHandle(int nStdHandle);

    static IntPtr GetStdOutputHandle() => GetStdHandle(STD_OUTPUT_HANDLE);
}

Answer 5

Ok, I don't have the solution, but it seems to be because the cmd.exe is not waiting on the started process, whereas with a normal console application cmd.exe waits until the the application exits. I don't know what makes cmd.exe decide to wait or not on an application, normal Windows Forms applications are just started and cmd.exe doesn't wait for it to exit. Maybe this hint triggers somebody! I will dig a bit deeper in the mean while.

Answer 6

Try calling the FreeConsole function prior to exiting your executable.