Запрет на повторный запуск программы

class Program : Application
    {       
        [STAThread]
        static void Main()
        {
           //Тут делай проверку запущенного процесса
           //Если все ок, то запускаем форму
 
            new Program();
        }
 
        public Program()
        {
            StartupUri = new System.Uri("/MainForm.xaml", UriKind.Relative);
            Run();           
        }
    }

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Text;
using System.Diagnostics;
using System.Threading;
using System.Reflection;
using System.IO;
 
namespace SingleInstance
{
    /// <summary>
    /// Summary description for SingleApp.
    /// </summary>
    public class SingleApplication
    {
        public SingleApplication()
        {
 
        }
        /// <summary>
        /// Imports 
        /// </summary>
    
        [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 int IsIconic(IntPtr hWnd);
 
        /// <summary>
        /// GetCurrentInstanceWindowHandle
        /// </summary>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// SwitchToCurrentInstance
        /// </summary>
        private static void SwitchToCurrentInstance()
        {    
            IntPtr hWnd = GetCurrentInstanceWindowHandle();
            if (hWnd != IntPtr.Zero)    
            {    
                // 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.
                SetForegroundWindow(hWnd);
            }
        }
 
        /// <summary>
        /// Execute a form base application if another instance already running on
        /// the system activate previous one
        /// </summary>
        /// <param name="frmMain">main form</param>
        /// <returns>true if no previous instance is running</returns>
        public static bool Run(System.Windows.Forms.Form frmMain)
        {
            if(IsAlreadyRunning())
            {
                //set focus on previously running app
                SwitchToCurrentInstance();
                return false;
            }
            Application.Run(frmMain);
            return true;
        }
 
        /// <summary>
        /// for console base application
        /// </summary>
        /// <returns></returns>
        public static bool Run()
        {
            if(IsAlreadyRunning()) 
            {
                return false;
            }
            return true;
        }
 
        /// <summary>
        /// check if given exe alread running or not
        /// </summary>
        /// <returns>returns true if already running</returns>
        private static bool IsAlreadyRunning()
        {
            string strLoc = Assembly.GetExecutingAssembly().Location;
            FileSystemInfo fileInfo = new FileInfo(strLoc);
            string sExeName = fileInfo.Name;
            bool bCreatedNew;
 
            mutex = new Mutex(true, "Global\\"+sExeName, out bCreatedNew);
            if (bCreatedNew)
                mutex.ReleaseMutex();
 
            return !bCreatedNew;
        }
        
        static Mutex mutex;
        const int SW_RESTORE = 9;
    }
}

static void Main() 
{
   if(SingleInstance.SingleApplication.Run() == false)
   {
      return;
   }
   // Начало программы.
}

public partial class App : Application
    {
        //Запуск одной копии приложения
        System.Threading.Mutex mut;
        private void App_Startup(object sender, StartupEventArgs e)
        {
            bool createdNew;
            string mutName = "Приложение";
            mut = new System.Threading.Mutex(true, mutName, out createdNew);
            if (!createdNew)
            {
                Shutdown();
            }
            
        }
    }

    public partial class App : Application
    {
        [DllImport("user32.dll", SetLastError = true)]
        internal static extern int ShowWindow(int hwnd, int nCmdShow);
 
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool SetForegroundWindow(IntPtr hWnd);
 
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
 
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            try
            {
                Process thisProc = Process.GetCurrentProcess();
                // Check how many total processes have the same name as the current one
                Process[] procs = Process.GetProcessesByName(thisProc.ProcessName);
                if (procs.Length > 1)
                {
                    foreach (Process proc in procs)
                    {
                        if (proc.Id != Process.GetCurrentProcess().Id)
                        {
                            // Пробовал и так
                            SendMessage(proc.MainWindowHandle, 0x99FF, IntPtr.Zero, IntPtr.Zero);
                            // И так
                            ShowWindow((int)proc.MainWindowHandle, 5);
                            SetForegroundWindow(proc.MainWindowHandle);
                        }
                    }
                    // If ther is more than one, than it is already running.
                    //MessageBox.Show("Одна копия приложения уже работает.");
                    Application.Current.Shutdown();
                    return;
                }
            }
            catch (Exception ex)
            {
 
            }
        }
    }

        private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            if (msg == 0x99FF)
            {
                // обрабатываем сообщение
                try
                {
                        this.Show();
                        this.Activate();
                }
                catch (Exception ex)
                {
 
                }
            }
            return IntPtr.Zero;
        }
 
        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            // создаем экземпляр HwndSource
            hwndSource = PresentationSource.FromVisual(this) as HwndSource;
            // и устанавливаем перехватчик
            hwndSource.AddHook(WndProc);
        }