How to Ensure Only One Instance of a WPF Application Runs at a Time?

Implementing Single-Instance Behavior in WPF Applications

This guide explains how to build a WPF application that allows only one instance to run concurrently. This is achieved using mutexes.

Understanding Mutexes

A mutex (mutual exclusion) is a synchronization primitive. It ensures that only a single process can access a shared resource at any given moment. In WPF, we leverage mutexes to prevent multiple application instances from running simultaneously.

Implementation Details

Utilizing Named Mutexes:

The preferred method involves creating a named mutex within your application's main entry point:

<code class="language-csharp">static class Program
{
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    // ...
}</code>

Named mutexes enable synchronization across multiple processes and threads.

Acquiring the Mutex:

To determine if another instance is already running, we use the WaitOne method:

<code class="language-csharp">if (mutex.WaitOne(TimeSpan.Zero, true))
{
    // Mutex acquired; application can start
    Application.Run(new MainWindow());
    mutex.ReleaseMutex();
}
else
{
    // Mutex unavailable; another instance is active
    MessageBox.Show("An instance is already running.");
}</code>

Optional: Notifying the Existing Instance:

For enhanced user experience, you can notify the running instance when a new launch is attempted. This is done using PostMessage:

<code class="language-csharp">if (!mutex.WaitOne(TimeSpan.Zero, true))
{
    NativeMethods.PostMessage(
        (IntPtr)NativeMethods.HWND_BROADCAST,
        NativeMethods.WM_SHOWME,
        IntPtr.Zero,
        IntPtr.Zero);
}</code>

Handling the Custom Win32 Message:

In your main window, override WndProc to listen for the custom message and bring the existing window to the foreground:

<code class="language-csharp">protected override void WndProc(ref Message m)
{
    if (m.Msg == NativeMethods.WM_SHOWME)
    {
        Activate(); // Bring to front
    }
    base.WndProc(ref m);
}</code>

This comprehensive approach ensures a robust single-instance WPF application, preventing multiple instances from running concurrently. Remember to include necessary NativeMethods definitions (not shown here for brevity).

The above is the detailed content of How to Ensure Only One Instance of a WPF Application Runs at a Time?. For more information, please follow other related articles on the PHP Chinese website!