Single Instance Application in C#

<br />
	[STAThread]<br />
	static void Main() <br />
	{<br />
		SingletonApplication.Run(new Form1(), true);<br />
	}<br />

<br />
	[STAThread]<br />
	static void Main() <br />
	{<br />
		SingletonApplication.Run(new Form1());<br />
	}<br />

/*    
 *  File: SingletonApplication.cs    
 *     
 */    
    
using System;    
using System.Diagnostics;    
using System.Reflection;    
using System.Runtime.InteropServices;    
using System.Threading;    
using System.Windows.Forms;    
    
namespace CompanyName.Win32.Util    
{    
    #region SingletonApplication    
    
    public sealed class SingletonApplication    
    {    
        #region Public Members    
    
        #region Run    
    
        public static bool Run(string name, System.Windows.Forms.Form form, bool global)    
        {    
            if (InternalIsRunning(name, global))    
            {    
                SwitchToCurrentInstance();    
                return false;    
            }    
            Application.Run(form);    
            return true;    
        }    
    
        public static bool Run(string name, System.Windows.Forms.Form form)    
        {    
            return Run(name, form, false);    
        }    
    
        public static bool Run(System.Windows.Forms.Form form, bool global)    
        {    
            return Run(GetApplicationName(), form, global);    
        }    
    
        public static bool Run(System.Windows.Forms.Form form)    
        {    
            return Run(GetApplicationName(), form, false);    
        }    
    
        public static bool Run(string name, bool global)    
        {    
            return !InternalIsRunning(name, global);    
        }    
    
        public static bool Run(string name)    
        {    
            return Run(name, false);    
        }    
    
        public static bool Run(bool global)    
        {    
            return Run(GetApplicationName(), global);    
        }    
    
        public static bool Run()    
        {    
            return Run(GetApplicationName(), false);    
        }    
    
        #endregion    
    
        #region IsRunning    
    
        public static bool IsRunning(string name, bool global)    
        {    
            // Create temporary mutex to test if application matching    
            // specified parameters is currently running.    
            bool createdNew;    
            Mutex _mutex = new Mutex(true, GetMutexName(name, global), out createdNew);    
            if (createdNew)    
                _mutex.ReleaseMutex();    
            return !createdNew;    
        }    
    
        public static bool IsRunning(string name)    
        {    
            return IsRunning(name, false);    
        }    
    
        public static bool IsRunning(bool global)    
        {    
            return IsRunning(GetApplicationName(), global);    
        }    
    
        public static bool IsRunning()    
        {    
            return IsRunning(GetApplicationName(), false);    
        }    
    
        #endregion    
    
        #region GetApplicationName    
    
        public static string GetApplicationName()    
        {    
            // Attempt to gaurantee a unique name, by using a static guid as well as the    
            // full name of the entry assembly with version info, culture info and public    
            // key token. Using the entry assembly, rather than the executing assembly    
            // allows this class to be packaged in another assembly.    
            return string.Format("a37e5577-a9c5-4837-ad17-288b9eb7b682, {0}",     
                Assembly.GetEntryAssembly().GetName().FullName);    
        }    
    
        #endregion    
    
        #endregion    
    
        #region Private Members    
    
        #region InternalIsRunning    
    
        private static bool InternalIsRunning(string name, bool global)    
        {    
            if (mutex == null)    
            {    
                mutex = new Mutex(true, GetMutexName(name, global));    
                // Mark the mutex as ineligable for garbage collection.    
                // Not technically necessary, since it is a static    
                // member, however, this may improve performace (unknown?)    
                // by elliminating unecessary checking of the member    
                // for garbage collection, since it must be alive as along    
                // as the application is alive.    
                GC.KeepAlive(mutex);    
            }    
            return !mutex.WaitOne(0, false);    
        }    
    
        #endregion    
    
        #region GetMutexName    
    
        private static string GetMutexName(string name, bool global)    
        {    
            // Create valid mutex name. Replace all "\" with "_".    
            // Add Global or Local prefix.    
            return string.Format(@"{0}\{1}",     
                global ? "Global" : "Local", name.Replace(@"\", "_"));    
        }    
    
        #endregion    
    
        #region SwitchToCurrentInstance    
    
        private static void SwitchToCurrentInstance()    
        {    
            IntPtr hWnd = GetCurrentInstanceWindowHandle();    
            if (hWnd != IntPtr.Zero)    
            {    
                // get current foreground window    
                IntPtr _hWnd = GetForegroundWindow();    
    
                // Restore window if minimised. Do not restore if already in    
                // normal or maximised window state, since we don't want to    
                // change the current state of the window.    
                if (IsIconic(hWnd) != 0)    
                    ShowWindow(hWnd, SW_RESTORE);    
    
                // Set foreground window. Attach thread input to ensure we can    
                // force the window to the foreground.    
                int hThread = GetWindowThreadProcessId(hWnd, IntPtr.Zero);    
                int _hThread = GetWindowThreadProcessId(_hWnd, IntPtr.Zero);    
            
                if (hThread != _hThread)    
                {    
                    AttachThreadInput(_hThread, hThread, 1);    
                    SetForegroundWindow(hWnd);    
                    AttachThreadInput(_hThread, hThread, 0);    
                }    
                else    
                    SetForegroundWindow(hWnd);    
            }    
        }    
    
        #endregion    
    
        #region GetCurrentInstanceWindowHandle    
    
        private static IntPtr GetCurrentInstanceWindowHandle()    
        {    
            IntPtr hWnd = IntPtr.Zero;    
            Process process = Process.GetCurrentProcess();    
            Process[] processes = Process.GetProcessesByName(process.ProcessName);    
            foreach(Process _process in processes)    
            {    
                // Get the first instance that is not this instance, has the    
                // same process name and was started from the same file name    
                // and location. Also check that the process has a valid     
                // window handle in this session to filter out other user's    
                // processes.    
                if (_process.Id != process.Id &&    
                    _process.MainModule.FileName == process.MainModule.FileName &&    
                    _process.MainWindowHandle != IntPtr.Zero)    
                {    
                    hWnd = _process.MainWindowHandle;    
                    break;    
                }    
            }        
            return hWnd;    
        }    
    
        #endregion    
    
        #region API Imports    
    
        [DllImport("user32.dll")]    
        private static extern int ShowWindow(IntPtr hWnd, int nCmdShow);    
    
        [DllImport("user32.dll")]    
        private static extern int SetForegroundWindow(IntPtr hWnd);    
    
        [DllImport("user32.dll")]    
        private static extern IntPtr GetForegroundWindow();    
    
        [DllImport("user32.dll")]    
        private static extern int GetWindowThreadProcessId(IntPtr hWnd, IntPtr lpdwProcessId);    
    
        [DllImport("user32.dll")]    
        private static extern int IsIconic(IntPtr hWnd);    
    
        [DllImport("user32.dll")]    
        private static extern int AttachThreadInput(int idAttach, int idAttachTo, int fAttach);    
    
        #endregion    
    
        #region Constructor    
    
        // Instances of this class cannot be constructed.    
        private SingletonApplication()    
        {}    
    
        #endregion    
    
        private const int SW_RESTORE = 9;    
        private static Mutex mutex;    
    
        #endregion    
    }    
    
    #endregion    
}    

static void Main()
{
  if (SingletonApplication.Run(SingletonApplicationScope.Local,
      SingletoneApplicationOptions.SwitchToCurrentInstance)
  {
    Form1 form1 = new Form1();
    Application.Run(form1);
  }
}

#region SingletonApplicationScope

/// <summary>
/// Indicates the scope for a single instance application.
/// </summary>
public enum SingletonApplicationScope
{
    None,
    Local,
    Global
}

#endregion

#region SingletonApplicationOptions

/// <summary>
/// Specifies options that affect how a single instance application is run.
/// </summary>
[Flags]
public enum SingletonApplicationOptions
{
    None = 0x0,
    SwitchToCurrentInstance = 0x1
}

#endregion

#region SingletonApplication

/// <summary>
/// This class facilitates single instance applications running in either
/// the global scope (all users) or local scope (per user session).
/// </summary>
public sealed class SingletonApplication
{
    #region Public Members

    #region Run

    /// <summary>
    /// Run a singleton application.
    /// </summary>
    public static bool Run()
    {
        return InternalRun(SingletonApplicationScope.None, SingletonApplicationOptions.None, GetDefaultApplicationName());
    }

    public static bool Run(SingletonApplicationScope scope)
    {
        return InternalRun(scope, SingletonApplicationOptions.None, GetDefaultApplicationName());
    }

    public static bool Run(SingletonApplicationScope scope, SingletonApplicationOptions options)
    {
        return InternalRun(scope, options, GetDefaultApplicationName());
    }

    public static bool Run(SingletonApplicationScope scope, SingletonApplicationOptions options, string applicationName)
    {
        if (applicationName == null)
            throw new ArgumentNullException("applicationName");

        if (applicationName.IndexOf('\\') != -1)
        {
            throw new ArgumentException(
                Resources.ResourceManager[Resources.ArgumentExceptionSingletonApplicationName],
                "applicationName");
        }

        return InternalRun(scope, options, applicationName);
    }

    #endregion

    #region IsRunning

    /// <summary>
    /// Test if a single instance application is running.
    /// </summary>
    public static bool IsRunning()
    {
        return InternalIsRunning(SingletonApplicationScope.None, GetDefaultApplicationName());
    }

    public static bool IsRunning(SingletonApplicationScope scope)
    {
        return InternalIsRunning(scope, GetDefaultApplicationName());
    }

    public static bool IsRunning(SingletonApplicationScope scope, string applicationName)
    {
        if (applicationName == null)
            throw new ArgumentNullException("applicationName");

        if (applicationName.IndexOf('\\') != -1)
        {
            throw new ArgumentException(
                Resources.ResourceManager[Resources.ArgumentExceptionSingletonApplicationName],
                "applicationName");
        }

        return InternalIsRunning(scope, applicationName);
    }

    #endregion

    public static void Exit()
    {
        if (_mutex != null)
        {
            _mutex.Close();
            _mutex = null;
        }
    }

    /// <summary>
    /// Attempt to guarantee a unique/repeatable name, by using the full
    /// name of the entry assembly with version info, culture info and
    /// public key token. Using the entry assembly, rather than the
    /// executing assembly allows this class to be packaged in another
    /// assembly.
    /// </summary>
    public static string GetDefaultApplicationName()
    {
        return Assembly.GetEntryAssembly().GetName().FullName;
    }

    #endregion

    #region Private Members

    private static bool InternalRun(SingletonApplicationScope scope, SingletonApplicationOptions options, string applicationName)
    {
        //
        // Create mutex kernal object if it does not exist.
        //
        string mutexName = GetMutexName(scope, applicationName);
        bool createdNew;
        Win32Mutex mutex = new Win32Mutex(true, mutexName, out createdNew, true);
        if (!createdNew)
        {
            mutex.Close();
            if (IsOptionSet(options, SingletonApplicationOptions.SwitchToCurrentInstance))
                SwitchToCurrentInstance();
            return false;
        }
        // Static mutex reference, since it must be alive
        // as along as the application is alive.
        _mutex = mutex;
        return true;
    }

    private static bool InternalIsRunning(SingletonApplicationScope scope, string applicationName)
    {
        //
        // Create temporary mutex to test if application matching
        // specified name is currently running.
        //
        bool createdNew = false;
        string mutexName = GetMutexName(scope, applicationName);
        using (Win32Mutex mutex = new Win32Mutex(true, mutexName, out createdNew, true))
        {
            if (createdNew)
                mutex.ReleaseMutex();
        }
        return !createdNew;
    }

    private static string GetMutexName(SingletonApplicationScope scope, string applicationName)
    {
        // Create a valid mutex name.
        // Note: applicationName must not contain "\".
        // Add Global or Local scope prefix.
        return String.Concat(GetMutexScope(scope),
            typeof(SingletonApplication).GUID.ToString("D", CultureInfo.InvariantCulture),
            applicationName);
    }

    private static string GetMutexScope(SingletonApplicationScope scope)
    {
        switch (scope)
        {
            case SingletonApplicationScope.Local: return @"Local\";
            case SingletonApplicationScope.Global: return @"Global\";
        }
        return String.Empty;
    }

    private static bool IsOptionSet(SingletonApplicationOptions options, SingletonApplicationOptions option)
    {
        // Test if option flag is set.
        return ((options & option) == option);
    }

    private static void SwitchToCurrentInstance()
    {
        IntPtr currentInstanceWindowHandle = GetCurrentInstanceWindowHandle();
        if (currentInstanceWindowHandle != IntPtr.Zero)
            SetForegroundWindow(currentInstanceWindowHandle);
    }

    private static void SetForegroundWindow(IntPtr targetWindowHandle)
    {
        // Set the target window as the foreground window if it not the
        // current foreground window.
        IntPtr foregroundWindowHandle = User32.GetForegroundWindow();
        if (targetWindowHandle != foregroundWindowHandle)
        {
            // If the target window was created by a different thread to the
            // current thread, we need to attach the thread input of the
            // current thread to the target window thread before setting the
            // target window as the foreground window.
            uint targetWindowThreadId = User32.GetWindowThreadProcessId(targetWindowHandle, IntPtr.Zero);
            uint currentThreadId = Kernel32.GetCurrentThreadId();
            if (currentThreadId == targetWindowThreadId)
                User32.SetForegroundWindow(targetWindowHandle);
            else
            {
                User32.AttachThreadInput(currentThreadId, targetWindowThreadId, true);
                User32.SetForegroundWindow(targetWindowHandle);
                User32.AttachThreadInput(currentThreadId, targetWindowThreadId, false);
            }
        }
        // Restore the window if it is minimised.
        if (User32.IsIconic(targetWindowHandle))
            User32.ShowWindow(targetWindowHandle, User32.ShowWindowCommand.SW_RESTORE);
    }

    private static IntPtr GetCurrentInstanceWindowHandle()
    {
        Process currentProcess = Process.GetCurrentProcess();
        // Limit the candidate processes by process name.
        // Note: On earlier .NET Framework versions, Process.ProcessName was
        // limited to 15 characters, thus it is still neccessary to verify that
        // Process.MainModule.FileName exactly matches the current process'
        // full executable path.
        Process[] processes = Process.GetProcessesByName(currentProcess.ProcessName);
        // Interate through the candidate processes looking for the first
        // valid candidate process.
        foreach (Process process in processes)
        {
            // Exclude the current process.
            if (process.Id != currentProcess.Id)
            {
                // Process.MainWindowHandle will return IntPtr.Zero if
                // the process has no main window in the current user
                // session. This elliminates all processes not for the
                // current user session, all processes that do not have a
                // valid window handle and any process that has exited.
                // This avoids a Win32Exception("Access Denied") if
                // Process.MainModule is called for a process in another
                // user session.
                //
                // Note: Process.WaitForInputIdle is not required since we
                // do not need the window handle of a process that is still
                // starting up. Process.WaitForInputIdle will throw a
                // Win32Exception("Access Denied") if the process exists in
                // another user session.
                IntPtr handle = process.MainWindowHandle;
                if (handle != IntPtr.Zero)
                {
                    try
                    {
                        // Verify that the candidate process was started from
                        // the exact same executable (full path).
                        if (process.MainModule.FileName == currentProcess.MainModule.FileName)
                            return handle;
                    }
                    catch(InvalidOperationException)
                    {
                        // Ignore the InvalidOperationException if the
                        // process was exited, otherwise rethrow the
                        // InvalidOperationException.
                        if (!process.HasExited)
                            throw;
                    }
                }
            }
        }
        return IntPtr.Zero;
    }

    private SingletonApplication()
    {
        // Prevent instances of the class from being constructed.
        throw new NotSupportedException();
    }

    private static Win32Mutex _mutex;

    #endregion
}

#endregion

/// <summary>
/// Microsoft Windows 32-bit native mutex kernel object.
///
/// This class is a replacement for the .NET Framework 1.1
/// System.Threading.Mutex class, providing and additional security
/// parameter to specific MUTEX_ALL_ACCESS to the 'Everyone' group.
///
/// The System.Threading.Mutex throws a security exception "Access Denied"
/// when attempting to create a named mutex from one user session,
/// to another user sessions that owns the already cerated named muetx,
/// where the user does not have rights on the machine for
/// MUTEX_ALL_ACCESS.
/// </summary>
public class Win32Mutex : WaitHandle
{
    #region Constructors

    public Win32Mutex()
    {
        bool createdNew;
        _handle = CreateMutex(false, null, false, out createdNew);
    }

    public Win32Mutex(bool initiallyOwned)
    {
        bool createdNew;
        _handle = CreateMutex(initiallyOwned, null, false, out createdNew);
    }

    public Win32Mutex(bool initiallyOwned, string name)
    {
        bool createdNew;
        _handle = CreateMutex(initiallyOwned, name, false, out createdNew);
    }

    public Win32Mutex(bool initiallyOwned, string name, out bool createdNew)
    {
        _handle = CreateMutex(initiallyOwned, name, false, out createdNew);
    }

    public Win32Mutex(bool initiallyOwned, string name, out bool createdNew, bool allAccess)
    {
        _handle = CreateMutex(initiallyOwned, name, allAccess, out createdNew);
    }

    #endregion

    #region Public Members

    public override IntPtr Handle
    {
        get { return _handle; }
        set {   _handle = value; }
    }

    public void ReleaseMutex()
    {
        if (_handle == WaitHandle.InvalidHandle)
            throw new ObjectDisposedException(GetType().FullName);
        ReleaseMutex(_handle);
    }

    #region WaitOne

    public override bool WaitOne()
    {
        if (_handle == WaitHandle.InvalidHandle)
            throw new ObjectDisposedException(GetType().FullName);
        return WaitForSingleObject(_handle, Kernel32.INFINITE);
    }

    public override bool WaitOne(int millisecondsTimeout, bool exitContext)
    {
        if (_handle == WaitHandle.InvalidHandle)
            throw new ObjectDisposedException(GetType().FullName);
        return WaitForSingleObject(_handle, millisecondsTimeout);
    }

    public override bool WaitOne(TimeSpan timeout, bool exitContext)
    {
        if (_handle == WaitHandle.InvalidHandle)
            throw new ObjectDisposedException(GetType().FullName);
        return WaitForSingleObject(_handle, (int)timeout.TotalMilliseconds);
    }

    #endregion

    #endregion

    #region Protected Members

    protected override void Dispose(bool explicitDisposing)
    {
        if (_handle != WaitHandle.InvalidHandle)
        {
            CloseHandle(_handle);
            _handle = WaitHandle.InvalidHandle;
        }
    }

    #endregion

    #region Private Members

    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    private IntPtr CreateMutex(bool initiallyOwned, string name, bool allAccess, out bool createdNew)
    {
        Kernel32.SECURITY_ATTRIBUTES lpMutexAttributes = null;

        if (allAccess)
        {
            lpMutexAttributes = new Kernel32.SECURITY_ATTRIBUTES();
            lpMutexAttributes.nLength = Marshal.SizeOf(lpMutexAttributes);
            lpMutexAttributes.bInheritHandle = true;
            lpMutexAttributes.lpSecurityDescriptor = 0;

            int securityDescriptorSize = 0;
            if (!AdvApi32.ConvertStringSecurityDescriptorToSecurityDescriptor(
                SDDL_MUTEX_ALL_ACCESS_EVERYONE,
                AdvApi32.SDDL_REVISION_1,
                ref lpMutexAttributes.lpSecurityDescriptor,
                ref securityDescriptorSize))
            {
                throw new Win32Exception();
            }
        }

        try
        {
            IntPtr handle = Kernel32.CreateMutex(lpMutexAttributes, initiallyOwned, name);
            int lastWin32Error = Marshal.GetLastWin32Error();
            if (handle == IntPtr.Zero)
            {
                throw new Win32Exception(lastWin32Error);
            }
            createdNew = (lastWin32Error != Kernel32.ERROR_ALREADY_EXISTS);
            return handle;
        }
        finally
        {
            if (lpMutexAttributes != null)
            {
                if (Kernel32.LocalFree((IntPtr)lpMutexAttributes.lpSecurityDescriptor) != IntPtr.Zero)
                {
                    throw new Win32Exception();
                }
            }
        }
    }

    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    private bool WaitForSingleObject(IntPtr handle, int millisecondsTimeout)
    {
        int ret;
        if ((ret = Kernel32.WaitForSingleObject(handle, millisecondsTimeout)) == Kernel32.WAIT_FAILED)
        {
            throw new Win32Exception();
        }
        return (ret != Kernel32.WAIT_TIMEOUT);
    }

    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    private void ReleaseMutex(IntPtr handle)
    {
        if (!Kernel32.ReleaseMutex(handle))
        {
            throw new Win32Exception();
        }
    }

    [SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    private void CloseHandle(IntPtr handle)
    {
        if (!Kernel32.CloseHandle(handle))
        {
            throw new Win32Exception();
        }
    }

    private const string SDDL_MUTEX_ALL_ACCESS_EVERYONE = "D:(A;NP;0x001f0001;;;WD)";
    private IntPtr _handle = WaitHandle.InvalidHandle;

    #endregion

<br />
public static bool Run(string frmText)<br />
{<br />
	sTitle = frmText;<br />
	if( EnumWindows (new EnumWinCallBack(EnumWindowCallBack), 0) == 0)<br />
	{<br />
		return false;<br />
	}<br />
	return true;<br />
}<br />

<br />
if(SingleInstance.SingleApplication.Run("MyForm"))<br />
	Application.Run(new MyForm());<br />

public static bool Run(string title, System.Type formType)
{
	if (IsAlreadyRunning())
	{
		_title = title;  // Get the applications title.
		// Enumerate through all windows and activate the existing instance.
		EnumWindows(new EnumWindowsCallback(EnumWindowsHandler), 0);
		return false;
	}
	Application.Run((System.Windows.Forms.Form)formType.GetConstructor(System.Type.EmptyTypes).Invoke(null));
	return true;
}