using System;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Win32APIs
{
    /// <summary>
    /// WindowsHelper implements managed wrappers for unmanaged Win32 APIs.
    /// </summary>
    public sealed class WindowsHelper
    {
        #region structures needed to call into unmanaged Win32 APIs.
        /// <summary>
        /// Point struct used for GetWindowPlacement API.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
            private class ManagedPt 
        {
            public int x = 0;
            public int y = 0;
            
            public ManagedPt() 
            {
            }

            public ManagedPt(int x, int y) 
            {
                this.x = x;
                this.y = y;
            }
        }

        /// <summary>
        /// Rect struct used for GetWindowPlacement API.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private class ManagedRect 
        {
            public int x = 0;
            public int y = 0;
            public int right = 0;
            public int bottom = 0;
            
            public ManagedRect() 
            {
            }

            public ManagedRect(int x, int y, int right, int bottom) 
            {
                this.x = x;
                this.y = y;
                this.right = right;
                this.bottom = bottom;
            }
        }

        /// <summary>
        /// WindowPlacement struct used for GetWindowPlacement API.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private class ManagedWindowPlacement 
        {
            public uint length = 0;
            public uint flags = 0;
            public uint showCmd = 0;
            public ManagedPt minPosition = null;
            public ManagedPt maxPosition = null;
            public ManagedRect normalPosition = null;
            
            public ManagedWindowPlacement() 
            {
                this.length = (uint)Marshal.SizeOf(this);
            }
        }
        #endregion

        // External Win32 APIs that we're calling directly.
        [DllImport("USER32.DLL", SetLastError=true)]
        private static extern uint ShowWindow (uint hwnd, int showCommand);
        
        [DllImport("USER32.DLL", SetLastError=true)]
        private static extern uint SetForegroundWindow (uint hwnd);
        
        [DllImport("USER32.DLL", SetLastError=true)]
        private static extern uint GetWindowPlacement (uint hwnd, 
            [In, Out]ManagedWindowPlacement lpwndpl);
        
        [DllImport("USER32.DLL", SetLastError=true)]
        private static extern uint FindWindow (string lpClassName, string lpWindowName);

        // Windows defined constants.
        private const int WM_ACTIVATE = 0x0006;
        private const int WA_CLICKACTIVE = 2;
        private const int SW_SHOWNORMAL = 1;
        private const int SW_SHOWMINIMIZED = 2;
        private const int SW_SHOWMAXIMIZED = 3;
        private const int WPF_RESTORETOMAXIMIZED = 2;

        /// <summary>
        /// Finds the specified window by its name (or caption). 
        /// </summary>
        /// <param name="windowName">Name of the window to find and activate.</param>
        /// <returns>Window handle or 0 if window not found by that name.</returns>
        static private uint FindWindow(string windowName)
        {
            // first, try to find the window by its window name or caption.
            uint hwndInstance = FindWindow(null, windowName);
            if (hwndInstance <= 0)
            {
                Debug.Assert(false, 
                    "Couldn't find window handle for the specified window name.");
            }

            return hwndInstance;
        }

        /// <summary>
        /// Finds the specified window by its name (or caption).  Then brings it to
        /// the foreground.
        /// </summary>
        /// <param name="windowName">Name of the window to find and activate.</param>
        static public void ActivateWindow(string windowName)
        {
            // first, try to find the window by its window name or caption.
            uint hwndInstance = FindWindow(windowName);

            // Then, get the WindowPlacement, so we can decide the best way to 
            // activate the window correctly.
            ManagedWindowPlacement placement = new ManagedWindowPlacement();
            GetWindowPlacement(hwndInstance, placement);

            if (placement.showCmd == SW_SHOWMINIMIZED)
            {
                // if the window is minimized, then we need to restore it to its
                // previous size.  we also take into account whether it was 
                // previously maximized.
                int showCmd = (placement.flags == WPF_RESTORETOMAXIMIZED) ? 
                    SW_SHOWMAXIMIZED : SW_SHOWNORMAL;
                ShowWindow(hwndInstance, showCmd);
            }
            else
            {
                // if it's not minimized, then we just call SetForegroundWindow to 
                // bring it to the front.
                SetForegroundWindow(hwndInstance);
            }
        }
    }
}

using System;
using System.Collections.Specialized;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using Win32APIs;

namespace SingleInstanceApp
{
    /// <summary>
    /// SingleInstanceHelper implements functionality to create single instance
    /// WinForms applications.
    /// </summary>
    public sealed class SingleInstanceHelper
    {
        // private member data.
        static private Mutex singleInstance = null;        // holds the mutex for this application.

        // private constants.
        private const string formatMutexName = "SingleInstanceMutex-{0}-{1}";

        /// <summary>
        /// Generates a unique identifier for this application's mutex based on its
        /// assembly name and version.
        /// </summary>
        static private string UniqueIdentifier
        {
            get
            {
                string appName = "";
                string appVersion = "0.0.0.0";
                Assembly entry = Assembly.GetEntryAssembly();

                if (entry != null) 
                {
                    AssemblyName assemblyName = entry.GetName();
                    if (assemblyName != null)
                    {
                        appName = assemblyName.Name;
                        appVersion = assemblyName.Version.ToString();
                    }
                }

                return string.Format(formatMutexName, appName, appVersion);
            }
        }

        /// <summary>
        /// Proxy method used by WinForm apps that want single instance behavior.
        /// This method will check if this is the first instance and create a new form of the
        /// specified type.  Otherwise, it will find the currently running instance and bring it
        /// to the foreground.
        /// </summary>
        /// <param name="newFormType">Type of the form to create if this is the first instance.</param>
        static public void ProxyMain(Type newFormType, string windowName)
        {
            // first, we create an instance of the Mutex with the appropriate identifier
            // for this app.
            singleInstance = new Mutex(false, UniqueIdentifier);

            // then, we attempt to lock the Mutex to see if its the first intance.
            // a Mutex can only ever have one lock on it at a time.
            if (singleInstance.WaitOne(1, true)) 
            {
                // if this is the first instance, then create an instance of the main Form.
                // we use the specified type and reflection to call the default constructor 
                // for the Form using Reflection.  That way this class is reuseable for any
                // applications you'd like to use it on.
                ConstructorInfo constructor = newFormType.GetConstructor(Type.EmptyTypes);
                Form newForm = (Form)constructor.Invoke(null);
                Application.Run(newForm);
            }
            else
            {
                // if its not the first instance, then bring the first one to the foreground.
                WindowsHelper.ActivateWindow(windowName);
            }
        }
    }
}

using System;
using System.Diagnostics;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;

namespace SingleInstanceApp
{
    /// <summary>
    /// Summary description for FormSingleInstanceApp.
    /// </summary>
    public class FormSingleInstanceApp : System.Windows.Forms.Form
    {
        // private constants;
        private const string windowName = "Single Instance App";

        // Windows Form Designer generated member data.
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.Label labelCurrentProcess;
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public FormSingleInstanceApp()
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose( bool disposing )
        {
            if( disposing )
            {
                if (components != null) 
                {
                    components.Dispose();
                }
            }
            base.Dispose( disposing );
        }

        // Windows Form Designer generated code removed for brevity...

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args) 
        {
            SingleInstanceHelper.ProxyMain(typeof(FormSingleInstanceApp), windowName);
        }

        private void FormSingleInstanceApp_Load(object sender, System.EventArgs e)
        {
            Process currentProcess = Process.GetCurrentProcess();
            if (currentProcess != null)
                this.labelCurrentProcess.Text = currentProcess.Id.ToString();
        }
    }
}