How do I know if my app was opened from console or windows in C#

Question

I have an application that is both gui and console.

Console: It executes from a windows schedule to do some automated tasks, so its called with an argument

GUI: Used for entering config parameters, a much nicer way for the user to do this than console.

All this works great. its primarily a console app, the console is hidden if its opened with no arguments and the configuration form is shown.

Problem: If I open it FROM the console with NO arguments, the console is hidden and the form is shown. how can i detect what or where i opened the app from, if it was opened from windows then hide the console, if it was opened from console then leave the console shown.

Answer 1

If you really want to know "where" your application has been started you have to know what is your parent process. In order to know your parent process you can read the solution of How to get parent process in .NET in managed way

Then you can for example check if your parent process name is explorer(windows) to open your application as a GUI.

sample code based on the solution provided in How to get parent process in .NET in managed way

namespace ConsoleApp1
{
    public static class ProcessExtensions
    {
        private static string FindIndexedProcessName(int pid)
        {
            var processName = Process.GetProcessById(pid).ProcessName;
            var processesByName = Process.GetProcessesByName(processName);
            string processIndexdName = null;

            for (var index = 0; index < processesByName.Length; index++)
            {
                processIndexdName = index == 0 ? processName : processName + "#" + index;
                var processId = new PerformanceCounter("Process", "ID Process", processIndexdName);
                if ((int)processId.NextValue() == pid)
                {
                    return processIndexdName;
                }
            }

            return processIndexdName;
        }
        private static Process FindPidFromIndexedProcessName(string indexedProcessName)
        {
            var parentId = new PerformanceCounter("Process", "Creating Process ID", indexedProcessName);
            return Process.GetProcessById((int)parentId.NextValue());
        }

        public static Process Parent(this Process process)
        {
            return FindPidFromIndexedProcessName(FindIndexedProcessName(process.Id));
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Process.GetCurrentProcess().Parent().ProcessName);
            Console.ReadKey();
        }
    }
}

This code will outputs:

• debug in visual studio: devenv
• start from windows: explorer
• start from cmd: cmd
• start from powershell console: powershell
• ...

Answer 2

One way to do this is to separate your cli version and gui version into 2 executable (like 7z do with 7z.exe a command line tool and 7zG the Gui version)

You could have 3 projects in visual studio:

• MyApp.Console (console app)
• MyApp.WindowsGui (winform/wpf app)
• MyApp.Logic (all the logic)

Console and WindowsGui have a reference to your Logic project

This will give you cleaner code as each "Frontend" project will handle only their purpose (handling GUI or console stuff) and your Logic are callable by both frontends

Answer 3

I am unclear as to what you're trying to achieve. From my understanding, the application will launch as a console application regardless of having arguments or not. To prevent it from disappearing, you can utilize a Boolean to prevent the window from closing while the user is inputting configuration. For example (syntax may not be 100% at DialogResult):

using System;
using System.Windows.Forms;

// Allows you to access the static objects of Console
//     without having to repeatedly type Console.Something.
using static System.Console;

static bool configured = false;
static bool showForm = false;
static void Main(string[] args) {
    showForm = args.Length < 1;
    if (showForm) {
        WriteLine("The application needs to be configured.");
        using (ConfigForm config = new ConfigForm()) {
            if (config.ShowDialog() == DialogResult.OK) {
                showForm = false;
                configured = true;
                // Set your configured arguments here.
            }
        }
    }

    // Prevents the console from closing.
    while (showForm)
        ReadKey();

    // Do your processing in this condition.
    if (!showForm && configured)
        WriteLine("Thanks for playing. Press any key to exit.");
    else // Retry or exit in this one.
        WriteLine("An error occurred. Press any key to exit.");

    ReadKey();
}

If your application is set as a console application then it will launch the console window by default. Now, if you need to show and hide your console at different times, you can look into this post where the accepted answer provides a proper way to utilize Windows API to achieve this without having to perform some shady logic to find the window by title or identity.

using System.Runtime.InteropServices;

[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;

var handle = GetConsoleWindow();

// Hide
ShowWindow(handle, SW_HIDE);

// Show
ShowWindow(handle, SW_SHOW);

If this doesn't solve what you need, feel free to be more thorough in your post and include some code to give more definition to your issue. I am unable to comment and ask questions so I gave a basic solution. If you have any questions, feel free to ask.

Answer 4

This might help:

using System;
using System.Diagnostics;

static class IsRanFromConsole
{
    private static readonly string[] consoleNames = {
        "cmd", "bash", "ash", "dash", "ksh", "zsh", "csh",
        "tcsh", "ch", "eshell", "fish", "psh", "pwsh", "rc",
        "sash", "scsh", "powershell", "tcc"
    };

    private static bool isCache = false;
    private static bool isConsole;

    public static bool IsConsole()
    {
        if (!isCache)
        {
            string parentProc = Process.GetCurrentProcess().Parent().ProcessName;
            isConsole = Array.IndexOf(consoleNames, parentProc) > -1;
        }
        return isConsole;
    }
}

Usage:

Console.WriteLine(IsRanFromConsole.IsConsole());

For the .Parent() function, you need to add this code.