Was ist der richtige Weg, um eine einzelne Instanz WPF-Anwendung zu erstellen?

Question

Verwendung von C# und WPF unter .NET (anstelle von Windows-Formulare oder Konsole), was ist der richtige Weg, um eine Anwendung zu erstellen, die nur als eine einzige Instanz ausgeführt werden kann?

Ich weiß, dass es etwas mit einem mythischen Ding namens Mutex zu tun hat, aber selten finde ich jemanden, der sich die Mühe macht, anzuhalten und zu erklären, was so etwas ist.

Der Code muss auch die bereits laufende Instanz darüber informieren, dass der Benutzer versucht hat, eine zweite Instanz zu starten, und vielleicht auch alle Befehlszeilenargumente übergeben, falls welche vorhanden sind.

Answer 1

[Nachfolgend habe ich Beispielcode für Konsolen- und WPF-Anwendungen bereitgestellt.]

Sie müssen nur den Wert des Parameters createdNew Variable (Beispiel unten!), nachdem Sie die benannte Mutex-Instanz erstellt haben.

Der boolesche createdNew wird zurückgegeben falsch:

wenn die Mutex-Instanz mit dem Namen "YourApplicationNameHere" bereits irgendwo auf dem System erstellt wurde

Der boolesche createdNew wird zurückgegeben wahr:

wenn dies der erste Mutex mit dem Namen "YourApplicationNameHere" auf dem System ist System ist.

---

Konsolenanwendung - Beispiel:

static Mutex m = null;

static void Main(string[] args)
{
    const string mutexName = "YourApplicationNameHere";
    bool createdNew = false;

    try
    {
        // Initializes a new instance of the Mutex class with a Boolean value that indicates 
        // whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, 
        // and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

        using (m = new Mutex(true, mutexName, out createdNew))
        {
            if (!createdNew)
            {
                Console.WriteLine("instance is alreday running... shutting down !!!");
                Console.Read();
                return; // Exit the application
            }

            // Run your windows forms app here
            Console.WriteLine("Single instance app is running!");
            Console.ReadLine();
        }

    }
    catch (Exception ex)
    {

        Console.WriteLine(ex.Message);
        Console.ReadLine();
    }
}

WPF-Beispiel:

public partial class App : Application
{
static Mutex m = null;

protected override void OnStartup(StartupEventArgs e)
{

    const string mutexName = "YourApplicationNameHere";
    bool createdNew = false;

    try
    {
        // Initializes a new instance of the Mutex class with a Boolean value that indicates 
        // whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, 
        // and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

        m = new Mutex(true, mutexName, out createdNew);

        if (!createdNew)
        {
            Current.Shutdown(); // Exit the application
        }

    }
    catch (Exception)
    {
        throw;
    }

    base.OnStartup(e);
}

protected override void OnExit(ExitEventArgs e)
{
    if (m != null)
    {
        m.Dispose();
    }
    base.OnExit(e);
}
}

Answer 2

Benannte Mutex-basierte Ansätze sind nicht plattformübergreifend, da benannte Mutexe in Mono nicht global sind. Auf Prozessaufzählung basierende Ansätze haben keine Synchronisation und können zu inkorrektem Verhalten führen (z.B. können sich mehrere gleichzeitig gestartete Prozesse abhängig vom Timing alle selbst beenden). Windowing-System-basierte Ansätze sind in einer Konsolenanwendung nicht wünschenswert. Diese Lösung, die auf der Antwort von Divin aufbaut, geht auf all diese Probleme ein:

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.");
            }
        }
    }
}

Answer 3

Ich benutze Mutex in meiner Lösung zur Verhinderung mehrerer Instanzen.

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();
}

Answer 4

Verwenden Sie die Mutex-Lösung:

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;
            }
        }
    }
}
}

Answer 5

Ich habe der Klasse NativeMethods eine sendMessage-Methode hinzugefügt.

Anscheinend funktioniert die Postmessage-Methode nicht, wenn die Anwendung nicht in der Taskleiste angezeigt wird, aber die Sendmessage-Methode löst dieses 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);
}