Jaki jest prawidłowy sposób utworzenia aplikacji WPF z pojedynczym wystąpieniem?

Używając C # i WPF w .NET (zamiast Windows Forms lub konsoli), jaki jest właściwy sposób na stworzenie aplikacji, którą można uruchomić tylko jako jedną instancję?

Wiem, że ma to coś wspólnego z mityczną rzeczą zwaną mutex, rzadko mogę znaleźć kogoś, kto będzie chciał się zatrzymać i wyjaśnić, co to jest.

Kod musi również informować działającą już instancję, że użytkownik próbował uruchomić drugą, a także może przekazać wszelkie argumenty wiersza polecenia, jeśli takie istnieją.

Oto bardzo dobry artykuł dotyczący rozwiązania Mutex. Podejście opisane w artykule jest korzystne z dwóch powodów.

Po pierwsze, nie wymaga zależności od zestawu Microsoft.VisualBasic. Gdyby mój projekt był już zależny od tego zestawu, prawdopodobnie zalecałbym użycie podejścia pokazanego w innej odpowiedzi . Ale w tej chwili nie używam zestawu Microsoft.VisualBasic i wolałbym nie dodawać niepotrzebnej zależności do mojego projektu.

Po drugie, artykuł pokazuje, jak przenieść istniejącą instancję aplikacji na pierwszy plan, gdy użytkownik próbuje uruchomić inną instancję. To bardzo miły akcent, którego nie opisują inne opisane tutaj rozwiązania Mutex.

AKTUALIZACJA

Na dzień 8.01.2014 artykuł, do którego odsyłam, jest nadal aktywny, ale blog nie był przez jakiś czas aktualizowany. Martwi mnie to, że ostatecznie może zniknąć, a wraz z nim zalecane rozwiązanie. Powielam tutaj treść artykułu dla potomności. Słowa należą wyłącznie do właściciela bloga w Sanity Free Coding .

Dzisiaj chciałem zmienić kod, który zabraniałby mojej aplikacji uruchamiania wielu własnych instancji.

Wcześniej korzystałem z System.Diagnostics.Process, aby wyszukać wystąpienie mojego myapp.exe na liście procesów. Podczas gdy to działa, powoduje to duże obciążenie i chciałem czegoś czystszego.

Wiedząc, że mogę do tego użyć muteksu (ale nigdy wcześniej tego nie robiłem) postanowiłem ograniczyć kod i uprościć moje życie.

W klasie mojej aplikacji głównej stworzyłem statyczny o nazwie Mutex :

static class Program
{
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    ...
}

Posiadanie nazwanego muteksu pozwala nam nakładać synchronizację na wiele wątków i procesów, co jest właśnie magią, której szukam.

Mutex.WaitOne ma przeciążenie, które określa czas oczekiwania. Ponieważ tak naprawdę nie chcemy synchronizować naszego kodu (wystarczy sprawdzić, czy jest on aktualnie używany), używamy przeciążenia z dwoma parametrami: Mutex.WaitOne (Limit czasu, bool exitContext) . Poczekaj, aż zwróci się prawda, jeśli można wejść, i fałsz, jeśli tak nie było. W tym przypadku wcale nie chcemy czekać; Jeśli używany jest nasz muteks, pomiń go i przejdź dalej, więc przekazujemy TimeSpan.Zero (odczekaj 0 milisekund) i ustawiamy exitContext na true, abyśmy mogli opuścić kontekst synchronizacji, zanim spróbujemy uzyskać na nim blokadę. Korzystając z tego, zawijamy nasz kod Application.Run wewnątrz czegoś takiego:

static class Program
{
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    static void Main() {
        if(mutex.WaitOne(TimeSpan.Zero, true)) {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
            mutex.ReleaseMutex();
        } else {
            MessageBox.Show("only one instance at a time");
        }
    }
}

Tak więc, jeśli nasza aplikacja jest uruchomiona, WaitOne zwróci false, a my otrzymamy okno komunikatu.

Zamiast wyświetlać okno komunikatu, zdecydowałem się użyć małego Win32, aby powiadomić moją działającą instancję, że ktoś zapomniał, że już działa (poprzez przejście na szczyt wszystkich innych okien). Aby to osiągnąć, użyłem PostMessage do wysłania niestandardowej wiadomości do każdego okna (wiadomość niestandardowa została zarejestrowana w RegisterWindowMessage przez moją uruchomioną aplikację, co oznacza, że ​​tylko moja aplikacja wie, co to jest), a następnie moja druga instancja kończy działanie. Działająca instancja aplikacji otrzyma to powiadomienie i przetworzy je. W tym celu zastąpiłem WndProc w mojej głównej formie i odsłuchałem moje niestandardowe powiadomienie. Kiedy otrzymałem to powiadomienie, ustawiłem właściwość TopMost formularza na true, aby wyświetlić ją na górze.

Oto, z czym skończyłem:

• Program.cs

static class Program
{
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    static void Main() {
        if(mutex.WaitOne(TimeSpan.Zero, true)) {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
            mutex.ReleaseMutex();
        } else {
            // send our Win32 message to make the currently running instance
            // jump on top of all the other windows
            NativeMethods.PostMessage(
                (IntPtr)NativeMethods.HWND_BROADCAST,
                NativeMethods.WM_SHOWME,
                IntPtr.Zero,
                IntPtr.Zero);
        }
    }
}

• NativeMethods.cs

// this class just wraps some Win32 stuff that we're going to use
internal class NativeMethods
{
    public const int HWND_BROADCAST = 0xffff;
    public static readonly int WM_SHOWME = RegisterWindowMessage("WM_SHOWME");
    [DllImport("user32")]
    public static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
    [DllImport("user32")]
    public static extern int RegisterWindowMessage(string message);
}

• Form1.cs (częściowe z przodu)

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    protected override void WndProc(ref Message m)
    {
        if(m.Msg == NativeMethods.WM_SHOWME) {
            ShowMe();
        }
        base.WndProc(ref m);
    }
    private void ShowMe()
    {
        if(WindowState == FormWindowState.Minimized) {
            WindowState = FormWindowState.Normal;
        }
        // get our current "TopMost" value (ours will always be false though)
        bool top = TopMost;
        // make our form jump to the top of everything
        TopMost = true;
        // set it back to whatever it was
        TopMost = top;
    }
}

Możesz użyć klasy Mutex, ale wkrótce przekonasz się, że będziesz musiał zaimplementować kod, aby przekazać argumenty i tym podobne. Cóż, nauczyłem się sztuczki podczas programowania w WinForm, kiedy czytałem książkę Chrisa Sella . Ta sztuczka wykorzystuje logikę, która jest już dla nas dostępna w ramach. Nie wiem o tobie, ale kiedy dowiaduję się o rzeczach, mogę ponownie użyć w ramie, zwykle taką drogę wybieram zamiast wymyślać koło. Chyba że oczywiście nie robi wszystkiego, czego chcę.

Kiedy dostałem się do WPF, wymyśliłem sposób użycia tego samego kodu, ale w aplikacji WPF. To rozwiązanie powinno zaspokoić twoje potrzeby w oparciu o twoje pytanie.

Najpierw musimy stworzyć naszą klasę aplikacji. W tej klasie przesłonimy zdarzenie OnStartup i stworzymy metodę o nazwie Activate, która zostanie wykorzystana później.

public class SingleInstanceApplication : System.Windows.Application
{
    protected override void OnStartup(System.Windows.StartupEventArgs e)
    {
        // Call the OnStartup event on our base class
        base.OnStartup(e);

        // Create our MainWindow and show it
        MainWindow window = new MainWindow();
        window.Show();
    }

    public void Activate()
    {
        // Reactivate the main window
        MainWindow.Activate();
    }
}

Po drugie, musimy stworzyć klasę, która będzie zarządzać naszymi instancjami. Zanim to przejdziemy, faktycznie ponownie wykorzystamy kod z zestawu Microsoft.VisualBasic. Ponieważ używam C # w tym przykładzie, musiałem odwołać się do zestawu. Jeśli korzystasz z VB.NET, nie musisz nic robić. Klasa, której będziemy używać, to WindowsFormsApplicationBase i dziedziczy po niej naszego menedżera instancji, a następnie wykorzystuje właściwości i zdarzenia do obsługi pojedynczego wystąpienia.

public class SingleInstanceManager : Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase
{
    private SingleInstanceApplication _application;
    private System.Collections.ObjectModel.ReadOnlyCollection<string> _commandLine;

    public SingleInstanceManager()
    {
        IsSingleInstance = true;
    }

    protected override bool OnStartup(Microsoft.VisualBasic.ApplicationServices.StartupEventArgs eventArgs)
    {
        // First time _application is launched
        _commandLine = eventArgs.CommandLine;
        _application = new SingleInstanceApplication();
        _application.Run();
        return false;
    }

    protected override void OnStartupNextInstance(StartupNextInstanceEventArgs eventArgs)
    {
        // Subsequent launches
        base.OnStartupNextInstance(eventArgs);
        _commandLine = eventArgs.CommandLine;
        _application.Activate();
    }
}

Zasadniczo używamy bitów VB do wykrywania pojedynczych instancji i odpowiedniego przetwarzania. OnStartup zostanie uruchomiony po załadowaniu pierwszej instancji. Program OnStartupNextInstance jest uruchamiany po ponownym uruchomieniu aplikacji. Jak widać, mogę dostać się do tego, co zostało przekazane w wierszu poleceń, za pomocą argumentów zdarzenia. Ustawiam wartość na pole instancji. Możesz parsować tutaj wiersz poleceń lub przekazać go do aplikacji przez konstruktor i wywołanie metody Activate.

Po trzecie, czas stworzyć nasz EntryPoint. Zamiast odświeżać aplikację tak, jak normalnie, skorzystamy z naszego narzędzia SingleInstanceManager.

public class EntryPoint
{
    [STAThread]
    public static void Main(string[] args)
    {
        SingleInstanceManager manager = new SingleInstanceManager();
        manager.Run(args);
    }
}

Mam nadzieję, że będziesz w stanie śledzić wszystko i będziesz mógł korzystać z tej implementacji i dostosować ją do własnych potrzeb.

Od tutaj .

Powszechnym zastosowaniem w wielu procesach Mutex jest zapewnienie, że jednocześnie może być uruchomiona tylko instancja programu. Oto jak to się robi:

class OneAtATimePlease {

  // Use a name unique to the application (eg include your company URL)
  static Mutex mutex = new Mutex (false, "oreilly.com OneAtATimeDemo");

  static void Main()
  {
    // Wait 5 seconds if contended – in case another instance
    // of the program is in the process of shutting down.
    if (!mutex.WaitOne(TimeSpan.FromSeconds (5), false))
    {
        Console.WriteLine("Another instance of the app is running. Bye!");
        return;
    }

    try
    {    
        Console.WriteLine("Running - press Enter to exit");
        Console.ReadLine();
    }
    finally
    {
        mutex.ReleaseMutex();
    }    
  }    
}

Dobrą cechą Mutex jest to, że jeśli aplikacja zakończy działanie bez uprzedniego wywołania ReleaseMutex, CLR automatycznie zwolni Mutex.

MSDN faktycznie ma przykładową aplikację dla C # i VB, która wykonuje dokładnie to: http://msdn.microsoft.com/en-us/library/ms771662(v=VS.90).aspx

Najpopularniejszą i niezawodną techniką opracowywania wykrywania pojedynczych instancji jest użycie infrastruktury zdalnej Microsoft .NET Framework (System.Remoting). Microsoft .NET Framework (wersja 2.0) zawiera typ WindowsFormsApplicationBase, który zawiera wymaganą funkcję zdalnego zarządzania. Aby włączyć ten typ do aplikacji WPF, typ musi z niego wywodzić i być używany jako podkładka między metodą statycznego punktu wejścia aplikacji, Main a typem aplikacji WPF. Podkładka wykrywa, kiedy aplikacja jest uruchamiana po raz pierwszy i kiedy podejmowane są kolejne próby uruchomienia, i daje kontrolę nad typem aplikacji WPF, aby określić sposób przetwarzania uruchomień.

• Dla C # ludzie biorą głęboki oddech i zapominają o całym „Nie chcę dołączać VisualBasic DLL”. Z tego powodu i tego, co mówi Scott Hanselman oraz z faktu, że jest to najczystsze rozwiązanie problemu i zostało zaprojektowane przez ludzi, którzy wiedzą o frameworku znacznie więcej niż ty.
• Z punktu widzenia użyteczności faktem jest, że jeśli użytkownik ładuje aplikację, która jest już otwarta i wyświetlasz komunikat o błędzie 'Another instance of the app is running. Bye', jakbyś nie był bardzo szczęśliwym użytkownikiem. Po prostu MUSISZ (w aplikacji GUI) przejść do tej aplikacji i przekazać podane argumenty - lub jeśli parametry wiersza poleceń nie mają znaczenia, musisz wyskoczyć z aplikacji, która mogła zostać zminimalizowana.

Framework ma już na to wsparcie - po prostu ten idiota nazwał DLL Microsoft.VisualBasici nie został wprowadzony Microsoft.ApplicationUtilslub coś takiego. Pokonaj go - lub otwórz Odbłyśnik.

Wskazówka: Jeśli zastosujesz to podejście dokładnie tak, jak jest, i masz już plik App.xaml z zasobami itp ., Również powinieneś się tym przyjrzeć .

Ten kod powinien przejść do głównej metody. Spójrz tutaj, aby uzyskać więcej informacji na temat głównej metody WPF.

[DllImport("user32.dll")]
private static extern Boolean ShowWindow(IntPtr hWnd, Int32 nCmdShow);

private const int SW_SHOWMAXIMIZED = 3;

static void Main() 
{
    Process currentProcess = Process.GetCurrentProcess();
    var runningProcess = (from process in Process.GetProcesses()
                          where
                            process.Id != currentProcess.Id &&
                            process.ProcessName.Equals(
                              currentProcess.ProcessName,
                              StringComparison.Ordinal)
                          select process).FirstOrDefault();
    if (runningProcess != null)
    {
        ShowWindow(runningProcess.MainWindowHandle, SW_SHOWMAXIMIZED);
       return; 
    }
}

Metoda 2

static void Main()
{
    string procName = Process.GetCurrentProcess().ProcessName;
    // get the list of all processes by that name

    Process[] processes=Process.GetProcessesByName(procName);

    if (processes.Length > 1)
    {
        MessageBox.Show(procName + " already running");  
        return;
    } 
    else
    {
        // Application.Run(...);
    }
}

Uwaga: powyższe metody zakładają, że proces / aplikacja ma unikalną nazwę. Ponieważ używa nazwy procesu, aby sprawdzić, czy istnieją istniejące procesory. Jeśli więc aplikacja ma bardzo popularną nazwę (np. Notatnik), powyższe podejście nie będzie działać.

Cóż, mam do tego jednorazową klasę, która z łatwością działa w większości przypadków użycia:

Użyj tego w ten sposób:

static void Main()
{
    using (SingleInstanceMutex sim = new SingleInstanceMutex())
    {
        if (sim.IsOtherInstanceRunning)
        {
            Application.Exit();
        }

        // Initialize program here.
    }
}

Oto on:

/// <summary>
/// Represents a <see cref="SingleInstanceMutex"/> class.
/// </summary>
public partial class SingleInstanceMutex : IDisposable
{
    #region Fields

    /// <summary>
    /// Indicator whether another instance of this application is running or not.
    /// </summary>
    private bool isNoOtherInstanceRunning;

    /// <summary>
    /// The <see cref="Mutex"/> used to ask for other instances of this application.
    /// </summary>
    private Mutex singleInstanceMutex = null;

    /// <summary>
    /// An indicator whether this object is beeing actively disposed or not.
    /// </summary>
    private bool disposed;

    #endregion

    #region Constructor

    /// <summary>
    /// Initializes a new instance of the <see cref="SingleInstanceMutex"/> class.
    /// </summary>
    public SingleInstanceMutex()
    {
        this.singleInstanceMutex = new Mutex(true, Assembly.GetCallingAssembly().FullName, out this.isNoOtherInstanceRunning);
    }

    #endregion

    #region Properties

    /// <summary>
    /// Gets an indicator whether another instance of the application is running or not.
    /// </summary>
    public bool IsOtherInstanceRunning
    {
        get
        {
            return !this.isNoOtherInstanceRunning;
        }
    }

    #endregion

    #region Methods

    /// <summary>
    /// Closes the <see cref="SingleInstanceMutex"/>.
    /// </summary>
    public void Close()
    {
        this.ThrowIfDisposed();
        this.singleInstanceMutex.Close();
    }

    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            /* Release unmanaged ressources */

            if (disposing)
            {
                /* Release managed ressources */
                this.Close();
            }

            this.disposed = true;
        }
    }

    /// <summary>
    /// Throws an exception if something is tried to be done with an already disposed object.
    /// </summary>
    /// <remarks>
    /// All public methods of the class must first call this.
    /// </remarks>
    public void ThrowIfDisposed()
    {
        if (this.disposed)
        {
            throw new ObjectDisposedException(this.GetType().Name);
        }
    }

    #endregion
}

Nowym, który korzysta z Mutex i IPC, a także przekazuje argumenty wiersza poleceń do działającej instancji, jest aplikacja pojedynczej instancji WPF .

Kod C # .NET Aplikacja pojedynczego wystąpienia która jest odnośnikiem do zaznaczonej odpowiedzi, jest świetnym początkiem.

Stwierdziłem jednak, że nie radzi sobie zbyt dobrze z przypadkami, gdy instancja, która już istnieje, ma otwarte okno dialogowe modalne, niezależnie od tego, czy jest to okno zarządzane (jak inny formularz, np. O polu), czy niezarządzane (takie jak OpenFileDialog nawet przy użyciu standardowej klasy .NET). W przypadku oryginalnego kodu aktywowana jest główna forma, ale modalna pozostaje nieaktywna, co wygląda dziwnie, a użytkownik musi ją kliknąć, aby móc nadal korzystać z aplikacji.

Tak więc utworzyłem klasę narzędzi użytkowych SingleInstance do obsługi tego wszystkiego dość automatycznie dla aplikacji Winforms i WPF.

Winforms :

1) zmodyfikuj klasę Programu w następujący sposób:

static class Program
{
    public static readonly SingleInstance Singleton = new SingleInstance(typeof(Program).FullName);

    [STAThread]
    static void Main(string[] args)
    {
        // NOTE: if this always return false, close & restart Visual Studio
        // this is probably due to the vshost.exe thing
        Singleton.RunFirstInstance(() =>
        {
            SingleInstanceMain(args);
        });
    }

    public static void SingleInstanceMain(string[] args)
    {
        // standard code that was in Main now goes here
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

2) zmodyfikuj klasę głównego okna w następujący sposób:

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

    protected override void WndProc(ref Message m)
    {
        // if needed, the singleton will restore this window
        Program.Singleton.OnWndProc(this, m, true);

        // TODO: handle specific messages here if needed
        base.WndProc(ref m);
    }
}

WPF:

1) zmodyfikuj stronę aplikacji w ten sposób (i upewnij się, że ustawiłeś akcję kompilacji na stronę, aby móc ponownie zdefiniować metodę główną):

public partial class App : Application
{
    public static readonly SingleInstance Singleton = new SingleInstance(typeof(App).FullName);

    [STAThread]
    public static void Main(string[] args)
    {
        // NOTE: if this always return false, close & restart Visual Studio
        // this is probably due to the vshost.exe thing
        Singleton.RunFirstInstance(() =>
        {
            SingleInstanceMain(args);
        });
    }

    public static void SingleInstanceMain(string[] args)
    {
        // standard code that was in Main now goes here
        App app = new App();
        app.InitializeComponent();
        app.Run();
    }
}

2) zmodyfikuj klasę głównego okna w następujący sposób:

public partial class MainWindow : Window
{
    private HwndSource _source;

    public MainWindow()
    {
        InitializeComponent();
    }

    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        _source = (HwndSource)PresentationSource.FromVisual(this);
        _source.AddHook(HwndSourceHook);
    }

    protected virtual IntPtr HwndSourceHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        // if needed, the singleton will restore this window
        App.Singleton.OnWndProc(hwnd, msg, wParam, lParam, true, true);

        // TODO: handle other specific message
        return IntPtr.Zero;
    }

A oto klasa użyteczności:

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Threading;

namespace SingleInstanceUtilities
{
    public sealed class SingleInstance
    {
        private const int HWND_BROADCAST = 0xFFFF;

        [DllImport("user32.dll")]
        private static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);

        [DllImport("user32.dll", CharSet = CharSet.Unicode)]
        private static extern int RegisterWindowMessage(string message);

        [DllImport("user32.dll")]
        private static extern bool SetForegroundWindow(IntPtr hWnd);

        public SingleInstance(string uniqueName)
        {
            if (uniqueName == null)
                throw new ArgumentNullException("uniqueName");

            Mutex = new Mutex(true, uniqueName);
            Message = RegisterWindowMessage("WM_" + uniqueName);
        }

        public Mutex Mutex { get; private set; }
        public int Message { get; private set; }

        public void RunFirstInstance(Action action)
        {
            RunFirstInstance(action, IntPtr.Zero, IntPtr.Zero);
        }

        // NOTE: if this always return false, close & restart Visual Studio
        // this is probably due to the vshost.exe thing
        public void RunFirstInstance(Action action, IntPtr wParam, IntPtr lParam)
        {
            if (action == null)
                throw new ArgumentNullException("action");

            if (WaitForMutext(wParam, lParam))
            {
                try
                {
                    action();
                }
                finally
                {
                    ReleaseMutex();
                }
            }
        }

        public static void ActivateWindow(IntPtr hwnd)
        {
            if (hwnd == IntPtr.Zero)
                return;

            FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(hwnd));
        }

        public void OnWndProc(IntPtr hwnd, int m, IntPtr wParam, IntPtr lParam, bool restorePlacement, bool activate)
        {
            if (m == Message)
            {
                if (restorePlacement)
                {
                    WindowPlacement placement = WindowPlacement.GetPlacement(hwnd, false);
                    if (placement.IsValid && placement.IsMinimized)
                    {
                        const int SW_SHOWNORMAL = 1;
                        placement.ShowCmd = SW_SHOWNORMAL;
                        placement.SetPlacement(hwnd);
                    }
                }

                if (activate)
                {
                    SetForegroundWindow(hwnd);
                    FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(hwnd));
                }
            }
        }

#if WINFORMS // define this for Winforms apps
        public void OnWndProc(System.Windows.Forms.Form form, int m, IntPtr wParam, IntPtr lParam, bool activate)
        {
            if (form == null)
                throw new ArgumentNullException("form");

            if (m == Message)
            {
                if (activate)
                {
                    if (form.WindowState == System.Windows.Forms.FormWindowState.Minimized)
                    {
                        form.WindowState = System.Windows.Forms.FormWindowState.Normal;
                    }

                    form.Activate();
                    FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(form.Handle));
                }
            }
        }

        public void OnWndProc(System.Windows.Forms.Form form, System.Windows.Forms.Message m, bool activate)
        {
            if (form == null)
                throw new ArgumentNullException("form");

            OnWndProc(form, m.Msg, m.WParam, m.LParam, activate);
        }
#endif

        public void ReleaseMutex()
        {
            Mutex.ReleaseMutex();
        }

        public bool WaitForMutext(bool force, IntPtr wParam, IntPtr lParam)
        {
            bool b = PrivateWaitForMutext(force);
            if (!b)
            {
                PostMessage((IntPtr)HWND_BROADCAST, Message, wParam, lParam);
            }
            return b;
        }

        public bool WaitForMutext(IntPtr wParam, IntPtr lParam)
        {
            return WaitForMutext(false, wParam, lParam);
        }

        private bool PrivateWaitForMutext(bool force)
        {
            if (force)
                return true;

            try
            {
                return Mutex.WaitOne(TimeSpan.Zero, true);
            }
            catch (AbandonedMutexException)
            {
                return true;
            }
        }
    }

    // NOTE: don't add any field or public get/set property, as this must exactly map to Windows' WINDOWPLACEMENT structure
    [StructLayout(LayoutKind.Sequential)]
    public struct WindowPlacement
    {
        public int Length { get; set; }
        public int Flags { get; set; }
        public int ShowCmd { get; set; }
        public int MinPositionX { get; set; }
        public int MinPositionY { get; set; }
        public int MaxPositionX { get; set; }
        public int MaxPositionY { get; set; }
        public int NormalPositionLeft { get; set; }
        public int NormalPositionTop { get; set; }
        public int NormalPositionRight { get; set; }
        public int NormalPositionBottom { get; set; }

        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool SetWindowPlacement(IntPtr hWnd, ref WindowPlacement lpwndpl);

        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool GetWindowPlacement(IntPtr hWnd, ref WindowPlacement lpwndpl);

        private const int SW_SHOWMINIMIZED = 2;

        public bool IsMinimized
        {
            get
            {
                return ShowCmd == SW_SHOWMINIMIZED;
            }
        }

        public bool IsValid
        {
            get
            {
                return Length == Marshal.SizeOf(typeof(WindowPlacement));
            }
        }

        public void SetPlacement(IntPtr windowHandle)
        {
            SetWindowPlacement(windowHandle, ref this);
        }

        public static WindowPlacement GetPlacement(IntPtr windowHandle, bool throwOnError)
        {
            WindowPlacement placement = new WindowPlacement();
            if (windowHandle == IntPtr.Zero)
                return placement;

            placement.Length = Marshal.SizeOf(typeof(WindowPlacement));
            if (!GetWindowPlacement(windowHandle, ref placement))
            {
                if (throwOnError)
                    throw new Win32Exception(Marshal.GetLastWin32Error());

                return new WindowPlacement();
            }
            return placement;
        }
    }

    public static class FormUtilities
    {
        [DllImport("user32.dll")]
        private static extern IntPtr GetWindow(IntPtr hWnd, int uCmd);

        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr SetActiveWindow(IntPtr hWnd);

        [DllImport("user32.dll")]
        private static extern bool IsWindowVisible(IntPtr hWnd);

        [DllImport("kernel32.dll")]
        public static extern int GetCurrentThreadId();

        private delegate bool EnumChildrenCallback(IntPtr hwnd, IntPtr lParam);

        [DllImport("user32.dll")]
        private static extern bool EnumThreadWindows(int dwThreadId, EnumChildrenCallback lpEnumFunc, IntPtr lParam);

        private class ModalWindowUtil
        {
            private const int GW_OWNER = 4;
            private int _maxOwnershipLevel;
            private IntPtr _maxOwnershipHandle;

            private bool EnumChildren(IntPtr hwnd, IntPtr lParam)
            {
                int level = 1;
                if (IsWindowVisible(hwnd) && IsOwned(lParam, hwnd, ref level))
                {
                    if (level > _maxOwnershipLevel)
                    {
                        _maxOwnershipHandle = hwnd;
                        _maxOwnershipLevel = level;
                    }
                }
                return true;
            }

            private static bool IsOwned(IntPtr owner, IntPtr hwnd, ref int level)
            {
                IntPtr o = GetWindow(hwnd, GW_OWNER);
                if (o == IntPtr.Zero)
                    return false;

                if (o == owner)
                    return true;

                level++;
                return IsOwned(owner, o, ref level);
            }

            public static void ActivateWindow(IntPtr hwnd)
            {
                if (hwnd != IntPtr.Zero)
                {
                    SetActiveWindow(hwnd);
                }
            }

            public static IntPtr GetModalWindow(IntPtr owner)
            {
                ModalWindowUtil util = new ModalWindowUtil();
                EnumThreadWindows(GetCurrentThreadId(), util.EnumChildren, owner);
                return util._maxOwnershipHandle; // may be IntPtr.Zero
            }
        }

        public static void ActivateWindow(IntPtr hwnd)
        {
            ModalWindowUtil.ActivateWindow(hwnd);
        }

        public static IntPtr GetModalWindow(IntPtr owner)
        {
            return ModalWindowUtil.GetModalWindow(owner);
        }
    }
}

Oto przykład, który pozwala mieć jedną instancję aplikacji. Po załadowaniu nowych instancji przekazują swoje argumenty do działającej instancji głównej.

public partial class App : Application
{
    private static Mutex SingleMutex;
    public static uint MessageId;

    private void Application_Startup(object sender, StartupEventArgs e)
    {
        IntPtr Result;
        IntPtr SendOk;
        Win32.COPYDATASTRUCT CopyData;
        string[] Args;
        IntPtr CopyDataMem;
        bool AllowMultipleInstances = false;

        Args = Environment.GetCommandLineArgs();

        // TODO: Replace {00000000-0000-0000-0000-000000000000} with your application's GUID
        MessageId   = Win32.RegisterWindowMessage("{00000000-0000-0000-0000-000000000000}");
        SingleMutex = new Mutex(false, "AppName");

        if ((AllowMultipleInstances) || (!AllowMultipleInstances && SingleMutex.WaitOne(1, true)))
        {
            new Main();
        }
        else if (Args.Length > 1)
        {
            foreach (Process Proc in Process.GetProcesses())
            {
                SendOk = Win32.SendMessageTimeout(Proc.MainWindowHandle, MessageId, IntPtr.Zero, IntPtr.Zero,
                    Win32.SendMessageTimeoutFlags.SMTO_BLOCK | Win32.SendMessageTimeoutFlags.SMTO_ABORTIFHUNG,
                    2000, out Result);

                if (SendOk == IntPtr.Zero)
                    continue;
                if ((uint)Result != MessageId)
                    continue;

                CopyDataMem = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Win32.COPYDATASTRUCT)));

                CopyData.dwData = IntPtr.Zero;
                CopyData.cbData = Args[1].Length*2;
                CopyData.lpData = Marshal.StringToHGlobalUni(Args[1]);

                Marshal.StructureToPtr(CopyData, CopyDataMem, false);

                Win32.SendMessageTimeout(Proc.MainWindowHandle, Win32.WM_COPYDATA, IntPtr.Zero, CopyDataMem,
                    Win32.SendMessageTimeoutFlags.SMTO_BLOCK | Win32.SendMessageTimeoutFlags.SMTO_ABORTIFHUNG,
                    5000, out Result);

                Marshal.FreeHGlobal(CopyData.lpData);
                Marshal.FreeHGlobal(CopyDataMem);
            }

            Shutdown(0);
        }
    }
}

public partial class Main : Window
{
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        HwndSource Source;

        Source = HwndSource.FromHwnd(new WindowInteropHelper(this).Handle);
        Source.AddHook(new HwndSourceHook(Window_Proc));
    }

    private IntPtr Window_Proc(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam, ref bool Handled)
    {
        Win32.COPYDATASTRUCT CopyData;
        string Path;

        if (Msg == Win32.WM_COPYDATA)
        {
            CopyData = (Win32.COPYDATASTRUCT)Marshal.PtrToStructure(lParam, typeof(Win32.COPYDATASTRUCT));
            Path = Marshal.PtrToStringUni(CopyData.lpData, CopyData.cbData / 2);

            if (WindowState == WindowState.Minimized)
            {
                // Restore window from tray
            }

            // Do whatever we want with information

            Activate();
            Focus();
        }

        if (Msg == App.MessageId)
        {
            Handled = true;
            return new IntPtr(App.MessageId);
        }

        return IntPtr.Zero;
    }
}

public class Win32
{
    public const uint WM_COPYDATA = 0x004A;

    public struct COPYDATASTRUCT
    {
        public IntPtr dwData;
        public int    cbData;
        public IntPtr lpData;
    }

    [Flags]
    public enum SendMessageTimeoutFlags : uint
    {
        SMTO_NORMAL             = 0x0000,
        SMTO_BLOCK              = 0x0001,
        SMTO_ABORTIFHUNG        = 0x0002,
        SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
    }

    [DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
    public static extern uint RegisterWindowMessage(string lpString);
    [DllImport("user32.dll")]
    public static extern IntPtr SendMessageTimeout(
        IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam,
        SendMessageTimeoutFlags fuFlags, uint uTimeout, out IntPtr lpdwResult);
}

Tylko kilka przemyśleń: zdarzają się sytuacje, w których wymaga się, aby tylko jedna instancja aplikacji nie była „kiepska”, jak niektórzy by chcieli. Aplikacje bazodanowe itp. Są o rząd wielkości trudniejsze, jeśli pozwala się na dostęp do bazy danych wielu wystąpieniom aplikacji dla jednego użytkownika (wszystko to aktualizuje wszystkie rekordy, które są otwarte w wielu wystąpieniach aplikacji na użytkownikach) maszyna itp.). Po pierwsze, w przypadku „kolizji nazw” nie używaj nazwy czytelnej dla człowieka - zamiast tego użyj identyfikatora GUID lub, nawet lepiej, identyfikatora GUID + nazwy czytelnej dla człowieka. Szanse kolizji nazwy spadły z radaru, a Mutex nie ma znaczenia Jak ktoś zauważył, atak DOS byłby do bani, ale gdyby złośliwa osoba zadała sobie trud uzyskania nazwy mutexu i włączenia jej do swojej aplikacji, i tak jesteś raczej celem i będziesz musiał zrobić DUŻO więcej, aby się bronić, niż po prostu bawić się mutexem. Ponadto, jeśli użyjesz wariantu: new Mutex (true, „GUID plus Name”, obecnie AIsFirstInstance), masz już wskaźnik tego, czy Mutex jest pierwszą instancją.

Tak wiele odpowiedzi na tak pozornie proste pytanie. Wystarczy trochę potrząsnąć tutaj, jest moim rozwiązaniem tego problemu.

Utworzenie Muteksu może być kłopotliwe, ponieważ JIT-er widzi, że używasz go tylko do niewielkiej części kodu i chce oznaczyć go jako gotowy do wyrzucania elementów bezużytecznych. Praktycznie chce obezwładnić cię myśląc, że nie będziesz używać tego Mutexa tak długo. W rzeczywistości chcesz trzymać się tego Mutexa tak długo, jak długo aplikacja jest uruchomiona. Najlepszym sposobem, aby powiedzieć śmieciarzowi, aby zostawił cię Mutex w spokoju, jest powiedzenie mu, aby utrzymał go przy życiu przez różne generacje kolekcji garażowych. Przykład:

var m = new Mutex(...);
...
GC.KeepAlive(m);

Podniosłem pomysł z tej strony: http://www.ai.uga.edu/~mc/SingleInstance.html

Wygląda na to, że istnieje naprawdę dobry sposób na poradzenie sobie z tym:

Aplikacja pojedynczego wystąpienia WPF

Zapewnia to klasę, którą można dodać, która zarządza wszystkimi muteksami i wątkami komunikacyjnymi, aby uprościć implementację do tego stopnia, że ​​jest to po prostu trywialne.

Poniższy kod to moje rozwiązanie nazwane potokami WCF do rejestracji aplikacji z pojedynczą instancją. To miłe, ponieważ wywołuje także zdarzenie, gdy inna instancja próbuje się uruchomić, i otrzymuje wiersz komendowy drugiej instancji.

Jest nastawiony na WPF, ponieważ wykorzystuje System.Windows.StartupEventHandlerklasę, ale można to łatwo zmodyfikować.

Ten kod wymaga odniesienia do PresentationFrameworki System.ServiceModel.

Stosowanie:

class Program
{
    static void Main()
    {
        var applicationId = new Guid("b54f7b0d-87f9-4df9-9686-4d8fd76066dc");

        if (SingleInstanceManager.VerifySingleInstance(applicationId))
        {
            SingleInstanceManager.OtherInstanceStarted += OnOtherInstanceStarted;

            // Start the application
        }
    }

    static void OnOtherInstanceStarted(object sender, StartupEventArgs e)
    {
        // Do something in response to another instance starting up.
    }
}

Kod źródłowy:

/// <summary>
/// A class to use for single-instance applications.
/// </summary>
public static class SingleInstanceManager
{
  /// <summary>
  /// Raised when another instance attempts to start up.
  /// </summary>
  public static event StartupEventHandler OtherInstanceStarted;

  /// <summary>
  /// Checks to see if this instance is the first instance running on this machine.  If it is not, this method will
  /// send the main instance this instance's startup information.
  /// </summary>
  /// <param name="guid">The application's unique identifier.</param>
  /// <returns>True if this instance is the main instance.</returns>
  public static bool VerifySingleInstace(Guid guid)
  {
    if (!AttemptPublishService(guid))
    {
      NotifyMainInstance(guid);

      return false;
    }

    return true;
  }

  /// <summary>
  /// Attempts to publish the service.
  /// </summary>
  /// <param name="guid">The application's unique identifier.</param>
  /// <returns>True if the service was published successfully.</returns>
  private static bool AttemptPublishService(Guid guid)
  {
    try
    {
      ServiceHost serviceHost = new ServiceHost(typeof(SingleInstance));
      NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
      serviceHost.AddServiceEndpoint(typeof(ISingleInstance), binding, CreateAddress(guid));
      serviceHost.Open();

      return true;
    }
    catch
    {
      return false;
    }
  }

  /// <summary>
  /// Notifies the main instance that this instance is attempting to start up.
  /// </summary>
  /// <param name="guid">The application's unique identifier.</param>
  private static void NotifyMainInstance(Guid guid)
  {
    NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
    EndpointAddress remoteAddress = new EndpointAddress(CreateAddress(guid));
    using (ChannelFactory<ISingleInstance> factory = new ChannelFactory<ISingleInstance>(binding, remoteAddress))
    {
      ISingleInstance singleInstance = factory.CreateChannel();
      singleInstance.NotifyMainInstance(Environment.GetCommandLineArgs());
    }
  }

  /// <summary>
  /// Creates an address to publish/contact the service at based on a globally unique identifier.
  /// </summary>
  /// <param name="guid">The identifier for the application.</param>
  /// <returns>The address to publish/contact the service.</returns>
  private static string CreateAddress(Guid guid)
  {
    return string.Format(CultureInfo.CurrentCulture, "net.pipe://localhost/{0}", guid);
  }

  /// <summary>
  /// The interface that describes the single instance service.
  /// </summary>
  [ServiceContract]
  private interface ISingleInstance
  {
    /// <summary>
    /// Notifies the main instance that another instance of the application attempted to start.
    /// </summary>
    /// <param name="args">The other instance's command-line arguments.</param>
    [OperationContract]
    void NotifyMainInstance(string[] args);
  }

  /// <summary>
  /// The implementation of the single instance service interface.
  /// </summary>
  private class SingleInstance : ISingleInstance
  {
    /// <summary>
    /// Notifies the main instance that another instance of the application attempted to start.
    /// </summary>
    /// <param name="args">The other instance's command-line arguments.</param>
    public void NotifyMainInstance(string[] args)
    {
      if (OtherInstanceStarted != null)
      {
        Type type = typeof(StartupEventArgs);
        ConstructorInfo constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
        StartupEventArgs e = (StartupEventArgs)constructor.Invoke(null);
        FieldInfo argsField = type.GetField("_args", BindingFlags.Instance | BindingFlags.NonPublic);
        Debug.Assert(argsField != null);
        argsField.SetValue(e, args);

        OtherInstanceStarted(null, e);
      }
    }
  }
}

Nigdy nie należy używać nazwanego muteksu do implementacji aplikacji z pojedynczą instancją (a przynajmniej nie do kodu produkcyjnego). Złośliwy kod może łatwo zrobić DoS ( Denial of Service ) tyłek ...

Spójrz na poniższy kod. Jest to świetne i proste rozwiązanie, aby zapobiec wielu wystąpieniom aplikacji WPF.

private void Application_Startup(object sender, StartupEventArgs e)
{
    Process thisProc = Process.GetCurrentProcess();
    if (Process.GetProcessesByName(thisProc.ProcessName).Length > 1)
    {
        MessageBox.Show("Application running");
        Application.Current.Shutdown();
        return;
    }

    var wLogin = new LoginWindow();

    if (wLogin.ShowDialog() == true)
    {
        var wMain = new Main();
        wMain.WindowState = WindowState.Maximized;
        wMain.Show();
    }
    else
    {
        Application.Current.Shutdown();
    }
}

Oto czego używam. Połączono wyliczanie procesów w celu wykonania przełączania i muteksu w celu zabezpieczenia przed „aktywnymi modułami klikającymi”:

public partial class App
{
    [DllImport("user32")]
    private static extern int OpenIcon(IntPtr hWnd);

    [DllImport("user32.dll")]
    private static extern bool SetForegroundWindow(IntPtr hWnd);

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
        var p = Process
           .GetProcessesByName(Process.GetCurrentProcess().ProcessName);
            foreach (var t in p.Where(t => t.MainWindowHandle != IntPtr.Zero))
            {
                OpenIcon(t.MainWindowHandle);
                SetForegroundWindow(t.MainWindowHandle);
                Current.Shutdown();
                return;
            }

            // there is a chance the user tries to click on the icon repeatedly
            // and the process cannot be discovered yet
            bool createdNew;
            var mutex = new Mutex(true, "MyAwesomeApp", 
               out createdNew);  // must be a variable, though it is unused - 
            // we just need a bit of time until the process shows up
            if (!createdNew)
            {
                Current.Shutdown();
                return;
            }

            new Bootstrapper().Run();
        }
    }

Znalazłem prostsze rozwiązanie, podobne do Dale Ragana, ale nieco zmodyfikowane. Robi praktycznie wszystko, czego potrzebujesz, w oparciu o standardową klasę Microsoft WindowsFormsApplicationBase.

Po pierwsze, tworzysz klasę SingleInstanceController, której możesz używać we wszystkich innych aplikacjach z pojedynczą instancją, które używają Windows Forms:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.VisualBasic.ApplicationServices;


namespace SingleInstanceController_NET
{
    public class SingleInstanceController
    : WindowsFormsApplicationBase
    {
        public delegate Form CreateMainForm();
        public delegate void StartNextInstanceDelegate(Form mainWindow);
        CreateMainForm formCreation;
        StartNextInstanceDelegate onStartNextInstance;
        public SingleInstanceController(CreateMainForm formCreation, StartNextInstanceDelegate onStartNextInstance)
        {
            // Set whether the application is single instance
            this.formCreation = formCreation;
            this.onStartNextInstance = onStartNextInstance;
            this.IsSingleInstance = true;

            this.StartupNextInstance += new StartupNextInstanceEventHandler(this_StartupNextInstance);                      
        }

        void this_StartupNextInstance(object sender, StartupNextInstanceEventArgs e)
        {
            if (onStartNextInstance != null)
            {
                onStartNextInstance(this.MainForm); // This code will be executed when the user tries to start the running program again,
                                                    // for example, by clicking on the exe file.
            }                                       // This code can determine how to re-activate the existing main window of the running application.
        }

        protected override void OnCreateMainForm()
        {
            // Instantiate your main application form
            this.MainForm = formCreation();
        }

        public void Run()
        {
            string[] commandLine = new string[0];
            base.Run(commandLine);
        }
    }
}

Następnie możesz użyć go w swoim programie w następujący sposób:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using SingleInstanceController_NET;

namespace SingleInstance
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static Form CreateForm()
        {
            return new Form1(); // Form1 is used for the main window.
        }

        static void OnStartNextInstance(Form mainWindow) // When the user tries to restart the application again,
                                                         // the main window is activated again.
        {
            mainWindow.WindowState = FormWindowState.Maximized;
        }
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);            
            SingleInstanceController controller = new SingleInstanceController(CreateForm, OnStartNextInstance);
            controller.Run();         
        }
    }
}

Zarówno program, jak i rozwiązanie SingleInstanceController_NET ​​powinny odwoływać się do Microsoft.VisualBasic. Jeśli chcesz ponownie aktywować działającą aplikację jako normalne okno, gdy użytkownik próbuje zrestartować uruchomiony program, drugi parametr w SingleInstanceController może mieć wartość NULL. W podanym przykładzie okno jest zmaksymalizowane.

Aktualizacja 2017-01-25. Po wypróbowaniu kilku rzeczy, zdecydowałem się na VisualBasic.dll, jest łatwiejszy i działa lepiej (przynajmniej dla mnie). Podaję moją poprzednią odpowiedź jako odniesienie ...

Jako odniesienie, tak zrobiłem bez przekazywania argumentów (co nie mogę znaleźć żadnego powodu, aby to zrobić ... Mam na myśli pojedynczą aplikację z argumentami, które mają być przekazywane z jednej instancji do drugiej). Jeśli wymagane jest powiązanie plików, aplikacja powinna (zgodnie ze standardowymi oczekiwaniami użytkowników) zostać utworzona dla każdego dokumentu. Jeśli musisz przekazać argumenty do istniejącej aplikacji, myślę, że użyłbym vb dll.

Nie przekazując argumentów (tylko aplikacja z pojedynczym wystąpieniem), wolę nie rejestrować nowej wiadomości Windows i nie zastępować pętli wiadomości, jak zdefiniowano w Matt Davis Solution. Chociaż dodanie dll VisualBasic nie jest niczym wielkim, ale wolę nie dodawać nowego odwołania tylko po to, aby zrobić aplikację z pojedynczą instancją. Wolę też zaimplementować nową klasę z Main zamiast wywoływać Shutdown z App.Startup override, aby zapewnić jak najszybsze wyjście.

Mam nadzieję, że każdemu się spodoba ... lub trochę zainspiruje :-)

Klasę uruchamiania projektu należy ustawić jako „SingleInstanceApp”.

public class SingleInstanceApp
{
    [STAThread]
    public static void Main(string[] args)
    {
        Mutex _mutexSingleInstance = new Mutex(true, "MonitorMeSingleInstance");

        if (_mutexSingleInstance.WaitOne(TimeSpan.Zero, true))
        {
            try
            {
                var app = new App();
                app.InitializeComponent();
                app.Run();

            }
            finally
            {
                _mutexSingleInstance.ReleaseMutex();
                _mutexSingleInstance.Close();
            }
        }
        else
        {
            MessageBox.Show("One instance is already running.");

            var processes = Process.GetProcessesByName(Assembly.GetEntryAssembly().GetName().Name);
            {
                if (processes.Length > 1)
                {
                    foreach (var process in processes)
                    {
                        if (process.Id != Process.GetCurrentProcess().Id)
                        {
                            WindowHelper.SetForegroundWindow(process.MainWindowHandle);
                        }
                    }
                }
            }
        }
    }
}

WindowHelper:

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Threading;

namespace HQ.Util.Unmanaged
{
    public class WindowHelper
    {
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool SetForegroundWindow(IntPtr hWnd);

Jednak nie używając Mutex, prosta odpowiedź:

System.Diagnostics;    
...
string thisprocessname = Process.GetCurrentProcess().ProcessName;

if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
                return;

Umieść w środku Program.Main().
Przykład :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;

namespace Sample
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            //simple add Diagnostics namespace, and these 3 lines below 
            string thisprocessname = Process.GetCurrentProcess().ProcessName;
            if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
                return;

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Sample());
        }
    }
}

Możesz dodać MessageBox.Showdo if-statement i umieścić „Aplikacja już działa”.
To może być komuś pomocne.

Podejścia oparte na muteksach nie są wieloplatformowe, ponieważ nazwane muteksy nie są globalne w Mono. Podejścia oparte na wyliczaniu procesów nie mają żadnej synchronizacji i mogą powodować nieprawidłowe zachowanie (np. Wiele procesów uruchomionych w tym samym czasie może zakończyć się samoczynnie w zależności od czasu). Podejścia oparte na systemie okienkowym nie są pożądane w aplikacji konsolowej. To rozwiązanie, oparte na odpowiedzi Divina, rozwiązuje wszystkie te problemy:

using System;
using System.IO;

namespace TestCs
{
    public class Program
    {
        // The app id must be unique. Generate a new guid for your application. 
        public static string AppId = "01234567-89ab-cdef-0123-456789abcdef";

        // The stream is stored globally to ensure that it won't be disposed before the application terminates.
        public static FileStream UniqueInstanceStream;

        public static int Main(string[] args)
        {
            EnsureUniqueInstance();

            // Your code here.

            return 0;
        }

        private static void EnsureUniqueInstance()
        {
            // Note: If you want the check to be per-user, use Environment.SpecialFolder.ApplicationData instead.
            string lockDir = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
                "UniqueInstanceApps");
            string lockPath = Path.Combine(lockDir, $"{AppId}.unique");

            Directory.CreateDirectory(lockDir);

            try
            {
                // Create the file with exclusive write access. If this fails, then another process is executing.
                UniqueInstanceStream = File.Open(lockPath, FileMode.Create, FileAccess.Write, FileShare.None);

                // Although only the line above should be sufficient, when debugging with a vshost on Visual Studio
                // (that acts as a proxy), the IO exception isn't passed to the application before a Write is executed.
                UniqueInstanceStream.Write(new byte[] { 0 }, 0, 1);
                UniqueInstanceStream.Flush();
            }
            catch
            {
                throw new Exception("Another instance of the application is already running.");
            }
        }
    }
}

Używam Mutex w swoim rozwiązaniu do zapobiegania wielu wystąpieniom.

static Mutex mutex = null;
//A string that is the name of the mutex
string mutexName = @"Global\test";
//Prevent Multiple Instances of Application
bool onlyInstance = false;
mutex = new Mutex(true, mutexName, out onlyInstance);

if (!onlyInstance)
{
  MessageBox.Show("You are already running this application in your system.", "Already Running..", MessageBoxButton.OK);
  Application.Current.Shutdown();
}

Użyj rozwiązania mutex:

using System;
using System.Windows.Forms;
using System.Threading;

namespace OneAndOnlyOne
{
static class Program
{
    static String _mutexID = " // generate guid"
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        Boolean _isNotRunning;
        using (Mutex _mutex = new Mutex(true, _mutexID, out _isNotRunning))
        {
            if (_isNotRunning)
            {
                Application.Run(new Form1());
            }
            else
            {
                MessageBox.Show("An instance is already running.");
                return;
            }
        }
    }
}
}

Oto lekkie rozwiązanie, którego używam, które pozwala aplikacji przenieść istniejące okno na pierwszy plan bez uciekania się do niestandardowych komunikatów systemu Windows lub ślepego wyszukiwania nazw procesów.

[DllImport("user32.dll")]
static extern bool SetForegroundWindow(IntPtr hWnd);

static readonly string guid = "<Application Guid>";

static void Main()
{
    Mutex mutex = null;
    if (!CreateMutex(out mutex))
        return;

    // Application startup code.

    Environment.SetEnvironmentVariable(guid, null, EnvironmentVariableTarget.User);
}

static bool CreateMutex(out Mutex mutex)
{
    bool createdNew = false;
    mutex = new Mutex(false, guid, out createdNew);

    if (createdNew)
    {
        Process process = Process.GetCurrentProcess();
        string value = process.Id.ToString();

        Environment.SetEnvironmentVariable(guid, value, EnvironmentVariableTarget.User);
    }
    else
    {
        string value = Environment.GetEnvironmentVariable(guid, EnvironmentVariableTarget.User);
        Process process = null;
        int processId = -1;

        if (int.TryParse(value, out processId))
            process = Process.GetProcessById(processId);

        if (process == null || !SetForegroundWindow(process.MainWindowHandle))
            MessageBox.Show("Unable to start application. An instance of this application is already running.");
    }

    return createdNew;
}

Edycja: Możesz także przechowywać i inicjować muteks i utworzony Nowy statycznie, ale będziesz musiał jawnie pozbyć się / zwolnić muteks, gdy skończysz. Osobiście wolę utrzymywać muteks lokalny, ponieważ zostanie on automatycznie zutylizowany, nawet jeśli aplikacja zostanie zamknięta bez osiągania końca Main.

Możesz także użyć CodeFluent Runtime, który jest bezpłatnym zestawem narzędzi. Zapewnia klasę SingleInstance do implementacji aplikacji z pojedynczą instancją.

Dodałem metodę sendMessage do klasy NativeMethods.

Najwyraźniej metoda postmessage nie działa, jeśli aplikacja nie jest wyświetlana na pasku zadań, jednak zastosowanie metody sendmessage rozwiązuje ten problem.

class NativeMethods
{
    public const int HWND_BROADCAST = 0xffff;
    public static readonly int WM_SHOWME = RegisterWindowMessage("WM_SHOWME");
    [DllImport("user32")]
    public static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
    [DllImport("user32")]
    public static extern int RegisterWindowMessage(string message);
}

Oto ta sama rzecz zaimplementowana przez Event.

public enum ApplicationSingleInstanceMode
{
    CurrentUserSession,
    AllSessionsOfCurrentUser,
    Pc
}

public class ApplicationSingleInstancePerUser: IDisposable
{
    private readonly EventWaitHandle _event;

    /// <summary>
    /// Shows if the current instance of ghost is the first
    /// </summary>
    public bool FirstInstance { get; private set; }

    /// <summary>
    /// Initializes 
    /// </summary>
    /// <param name="applicationName">The application name</param>
    /// <param name="mode">The single mode</param>
    public ApplicationSingleInstancePerUser(string applicationName, ApplicationSingleInstanceMode mode = ApplicationSingleInstanceMode.CurrentUserSession)
    {
        string name;
        if (mode == ApplicationSingleInstanceMode.CurrentUserSession)
            name = $"Local\\{applicationName}";
        else if (mode == ApplicationSingleInstanceMode.AllSessionsOfCurrentUser)
            name = $"Global\\{applicationName}{Environment.UserDomainName}";
        else
            name = $"Global\\{applicationName}";

        try
        {
            bool created;
            _event = new EventWaitHandle(false, EventResetMode.ManualReset, name, out created);
            FirstInstance = created;
        }
        catch
        {
        }
    }

    public void Dispose()
    {
        _event.Dispose();
    }
}