How to check If A User Has a browser open in C#

Question

I’ve created a WinForms application with a button. When a user presses that button I want my application to detect if a web browser is open such as Chrome, IE or Firefox and if it is, I want a message to show, like in

Message.Show("Browser Was Detected As Open", 
             "Success",
             MessageBoxButtons.OK, 
             MessageBoxIcon.None); 

And for an “else if” browser isn’t detected open an Error Box saying “Please Open Browser”.

I’m new to C# it’s probably a pretty simple few lines of Code.

If anyone can answer this thank you so much! Please include the #using statements!

Answer 1

Since you wrote you're using WinForms, I'm assuming you're on Windows. AFAIK there are 2 methods to do this - using the Process class or using WinAPI.

I'm not gonna cover the WinAPI variant, because it's longer and more complicated, also I don't really use it (most tasks can be accomplished using pure C#).

You can call this method in your button.Click event handler:

private void DetectOpenBrowser()
{
    var detector = new BrowserDetector();
    if (detector.BrowserIsOpen())
    {
        MessageBox.Show(this, "Browser Was Detected As Open", "Success", MessageBoxButtons.OK);
    }
    else
    {
        MessageBox.Show(this, "Please Open Browser", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

BrowserDetector class:

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

internal class BrowserDetector
{
    private readonly Dictionary<string, string> browsers = new Dictionary<string, string>
                                                  {
                                                      {
                                                          "firefox", "Mozilla Firefox"
                                                      },
                                                      {
                                                          "chrome", "Google Chrome"
                                                      },
                                                      {
                                                          "iexplore", "Internet Explorer"
                                                      },
                                                      {
                                                          "MicrosoftEdgeCP", "Microsoft Edge"
                                                      }
                                                      // add other browsers
                                                  };

    public bool BrowserIsOpen()
    {
        return Process.GetProcesses().Any(this.IsBrowserWithWindow);
    }

    private bool IsBrowserWithWindow(Process process)
    {
        return this.browsers.TryGetValue(process.ProcessName, out var browserTitle) && process.MainWindowTitle.Contains(browserTitle);
    }
}

Notes

I'm not sure whether all browsers have their name in the window title, I just checked those that I have available.

For adding other browsers you would need to find the process name in Task Manager, Details tab - e.g. for Firefox the entry is "firefox.exe", so the process name is "firefox". If there are different process names, like "MicrosoftEdge" and "MicrosoftEdgeCP", you're gonna need to experiment a bit to figure out which process has the main window.

Answer 2

You can refer to the following code to detect if the browser is opened by using windows API.

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            var RunningProcessPaths = ProcessFileNameFinderClass.GetAllRunningProcessFilePaths();

            if (RunningProcessPaths.Contains("firefox.exe"))
            {
                MessageBox.Show("Firefox Browser Was Detected As Open",
              "Success",
              MessageBoxButtons.OK,
              MessageBoxIcon.None);
            }

            if (RunningProcessPaths.Contains("chrome.exe"))
            {
                MessageBox.Show("Google chrome Browser Was Detected As Open",
                "Success",
                MessageBoxButtons.OK,
                MessageBoxIcon.None);
            }
            if (RunningProcessPaths.Contains("iexplore.exe"))
            {
                MessageBox.Show("IE Browser Was Detected As Open",
              "Success",
              MessageBoxButtons.OK,
              MessageBoxIcon.None);
            }
            //MicrosoftEdge.exe
            if (RunningProcessPaths.Contains("MicrosoftEdge.exe"))
            {
                MessageBox.Show("Microsoft Edge Browser Was Detected As Open",
              "Success",
              MessageBoxButtons.OK,
              MessageBoxIcon.None);
            }

        }
    }



  public class ProcessFileNameFinderClass
    {
        public static HashSet<string> GetAllRunningProcessFilePaths()
        {
            var allProcesses = System.Diagnostics.Process.GetProcesses();
            HashSet<string> ProcessExeNames = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
            foreach (Process p in allProcesses)
            {
                string processExePath = GetProcessExecutablePath(p);
                ProcessExeNames.Add(System.IO.Path.GetFileName(processExePath));
            }
            return ProcessExeNames;
        }


        /// <summary>
        /// Get executable path of running process
        /// </summary>
        /// <param name="Process"></param>
        /// <returns></returns>
        public static string GetProcessExecutablePath(Process Process)
        {
            try
            {
                if (Environment.OSVersion.Version.Major >= 6)
                {
                    return GetExecutablePathAboveXP(Process.Id);// this gets the process file name without running as administrator 
                }
                return Process.MainModule.FileName;// Vista and later this requires running as administrator.
            }
            catch
            {
                return "";
            }
        }

        public static string GetExecutablePathAboveXP(int ProcessId)
        {
            int MAX_PATH = 260;
            StringBuilder sb = new StringBuilder(MAX_PATH + 1);
            IntPtr hprocess = OpenProcess(ProcessAccessFlags.PROCESS_QUERY_LIMITED_INFORMATION, false, ProcessId);
            if (hprocess != IntPtr.Zero)
            {
                try
                {
                    int size = sb.Capacity;
                    if (QueryFullProcessImageName(hprocess, 0, sb, ref size))
                    {
                        return sb.ToString();
                    }
                }
                finally
                {
                    CloseHandle(hprocess);
                }
            }
            return "";
        }

        [Flags()]
        private enum ProcessAccessFlags : uint
        {
            PROCESS_ALL_ACCESS = 0x1f0fff,
            PROCESS_TERMINATE = 0x1,
            PROCESS_CREATE_THREAD = 0x2,
            PROCESS_VM_OPERATION = 0x8,
            PROCESS_VM_READ = 0x10,
            PROCESS_VM_WRITE = 0x20,
            PROCESS_DUP_HANDLE = 0x40,
            PROCESS_SET_INFORMATION = 0x200,
            PROCESS_SET_QUOTA = 0x100,
            PROCESS_QUERY_INFORMATION = 0x400,
            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000,
            SYNCHRONIZE = 0x100000,
            PROCESS_CREATE_PROCESS = 0x80,
            PROCESS_SUSPEND_RESUME = 0x800
        }

        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        private static extern bool QueryFullProcessImageName(IntPtr hProcess, uint dwFlags, [Out(), MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpExeName, ref int lpdwSize);

        [DllImport("kernel32.dll")]
        private static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);

        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool CloseHandle(IntPtr hHandle);
    }

You can try it with google chrome, IE, MicorsoftEdge and Firefox.

Answer 3

I tried to use the answers above but I am not satisfied with checking all the processes running nor checking the title because of localization and likely customization by search engines. Here is my quick and effective solution which checks for the presence of the browsers and also check if they have at least 1 active window.

internal static bool CheckIfAnyBrowserIsRunning()
        {
            bool answer = false;
            foreach(var browser in GetBrowsers())
            {
                Process[] Processes = Process.GetProcessesByName(browser);
                if (Processes.Length <= 0)
                    continue;
                if (!Processes.Any(d=>d.MainWindowHandle != IntPtr.Zero))
                    continue;
                answer = true;
                break;
            }
            return answer;
        }

internal static List<string> GetBrowsers()
        {
            return new List<string>() { "chrome", "msedge", "firefox" }; //add other browser process names
        }