Как запретить одновременный запуск нескольких копий программы

using System.Threading;
using System.Windows.Forms;
public class MyForm : Form
{
  private const string AppMutexName = "SingleApp";
  public static void Main()
  {
    using (Mutex mutex = new Mutex(false, AppMutexName))
    {
      bool Running = !mutex.WaitOne(0, false);
      if(!Running)
      {
        Application.Run(new MyForm());
      }
      else
      {
        // App already launched.
        MessageBox.Show("Im luanched!");
      }
    }
  }
}

   static class Program
   {      
       [DllImport("user32.dll")]
       [return: MarshalAs(UnmanagedType.Bool)]
       static extern bool SetForegroundWindow(IntPtr hWnd);
 
      /// 
      /// Главная точка входа для приложения.
      /// 
      [STAThread]
      static void Main()
      {                    
         bool createdNew = true;
         using (Mutex mutex = new Mutex(true, "MyApplicationName", out createdNew))
         {
             if (createdNew)
             {
                 Application.EnableVisualStyles();
                 Application.SetCompatibleTextRenderingDefault(false);
                 Application.Run(new Form_Main());
             }
             else
             {
                 Process current = Process.GetCurrentProcess();
                
                foreach (Process process in Process.GetProcessesByName(current.ProcessName))
                 {
                     if (process.Id != current.Id)
                     {
                         SetForegroundWindow(process.MainWindowHandle);
                         break;
                     }
                 }
             }
         }
 
      }
   }

static void Main() 
        {           
            if(System.Diagnostics.Process.GetProcessesByName(Application.ProductName).Length > 1)
            {
                MessageBox.Show("Приложение уже запущено");
                return;
            }
            else
            {
                Application.Run(new Form1());
            }
        }

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.IO;
 
namespace RunOnlyOne
{
    public static class RunOnlyOneClass
    {
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool SetForegroundWindow(IntPtr hWnd);
 
        [DllImport("user32.dll", SetLastError = true)]
        internal static extern int ShowWindow(int hwnd, int nCmdShow);
 
        //[DllImport("user32.dll", SetLastError = true)]
        //internal static extern int GetWindow(int hwnd, int nCmdShow);
 
        static Mutex _syncObject;        
        static readonly string AppPath = Path.GetFileNameWithoutExtension(Application.ExecutablePath);
 
        /// <summary>
        /// Находит запущенную копию приложения и разворачивает окно
        /// </summary>
        /// <param name="UniqueValue">уникальное значение для каждой программы (можно имя)</param>
        /// <returns>true - если приложение было запущено</returns>
        public static bool ChekRunProgramm(string UniqueValue)
        {
            bool applicationRun = false;             
            _syncObject = new Mutex(true, UniqueValue, out applicationRun);
            if (!applicationRun)
            {//восстановить/развернуть окно                              
                try
                {
                    Process[] procs = Process.GetProcessesByName(AppPath);
 
                    foreach (Process proc in procs)
                        if (proc.Id != Process.GetCurrentProcess().Id)
                        {
                            ShowWindow((int)proc.MainWindowHandle, 1);//нормально развернутое
                            //ShowWindow((int)proc.MainWindowHandle, 3);//максимально развернутое
                            SetForegroundWindow(proc.MainWindowHandle);                            
                            
                            break;
                        }
                }
                catch { return false; }                
            }
            return !applicationRun;
        }
    }
}

[STAThread]
        static void Main()
        {
            if (RunOnlyOneClass.ChekRunProgramm("Test")) return;
            
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());            
        }

using System;
using System.Threading;
public static class Program {
public static void Main() {
Boolean createdNew;
// Try to create a kernel object with the specified name
using (new Semaphore(0, 1, "SomeUniqueStringIdentifyingMyApp", out createdNew)) {
if (createdNew) {
// This thread created the kernel object so no other instance of this
// application must be running. Run the rest of the application here...
} else {
// This thread opened an existing kernel object with the same string name;
// another instance of this application must be running now.
// There is nothing to do in here, let's just return from Main to terminate
// this second instance of the application.
}
}
}
}