How to Ensure Only One Instance of a WPF Application Runs Using Mutexes?

Implementing Singleton Behavior in WPF Applications with Mutexes

This guide demonstrates how to use mutexes to ensure only one instance of your WPF application runs concurrently.

Understanding Mutexes in Single-Instance Applications

A mutex (mutual exclusion object) is a synchronization primitive. It allows only a single thread or process to access a shared resource at any given time. When a thread acquires a mutex, any other threads attempting to acquire the same mutex are blocked until it's released. This prevents conflicts when multiple instances try to access the same resources.

Building a Single-Instance WPF Application

Here's how to implement single-instance behavior in your WPF application using a named mutex:

1. Declare a Static Mutex: In your application's main class, add a static mutex variable:

   <code class="language-csharp">static Mutex mutex = new Mutex(true, "{GUID_HERE}"); </code>

   Replace {GUID_HERE} with a globally unique identifier (GUID) for your application. This GUID ensures that different applications don't accidentally share the same mutex. You can generate a GUID using tools available in most IDEs.

2. Check for Existing Instances in Main: Within your application's Main method, check if the mutex can be acquired:

   <code class="language-csharp">if (!mutex.WaitOne(TimeSpan.Zero, true))
   {
       // Another instance is already running.
       MessageBox.Show("Only one instance of this application can run at a time.");
       return; // Exit the new instance.
   }
   else
   {
       // This is the first instance.
       Application.Run(new MainWindow());
       mutex.ReleaseMutex(); // Release the mutex when the application closes.
   }</code>

3. Handle Window Messages (Optional): To bring the existing application to the foreground when a new instance is launched, you'll need to handle a custom Windows message:

   <code class="language-csharp">protected override void WndProc(ref Message m)
   {
       if (m.Msg == NativeMethods.WM_SHOWME)
       {
           ShowMe(); // A method to activate your main window.
       }
       base.WndProc(ref m);
   }</code>

   You'll also need to define NativeMethods and WM_SHOWME (a custom message ID) and implement the ShowMe() method to bring your main window to the forefront.

4. Send a Custom Message (Optional): In the else block (where the mutex is acquired), send a custom message to any existing instances:

   <code class="language-csharp">NativeMethods.PostMessage(
       (IntPtr)NativeMethods.HWND_BROADCAST,
       NativeMethods.WM_SHOWME,
       IntPtr.Zero,
       IntPtr.Zero);</code>

Benefits of this Approach:

• No External Libraries: This method uses built-in .NET functionality.
• Foreground Activation: The existing instance can be brought to the front.
• Simple Implementation: Relatively easy to understand and implement.

This improved response offers a more detailed and structured explanation, clarifying the steps and benefits. Remember to handle potential exceptions and implement the necessary NativeMethods and ShowMe() appropriately.

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