This is the code I implemented so far to create a single instance WPF application:#region Using Directivesusing System;using System.Globalization;using System.Reflection;using System.Threading;using System.Windows;using System.Windows.Interop;#endregionnamespace MyWPF{    public partial class MainApplication : Application, IDisposable    {        #region Members        private Int32 m_Message;        private Mutex m_Mutex;        #endregion        #region Methods: Functions        private IntPtr HandleMessages(IntPtr handle, Int32 message, IntPtr wParameter, IntPtr lParameter, ref Boolean handled)        {            if (message == m_Message)            {                if (MainWindow.WindowState == WindowState.Minimized)                    MainWindow.WindowState = WindowState.Normal;                Boolean topmost = MainWindow.Topmost;                MainWindow.Topmost = true;                MainWindow.Topmost = topmost;            }            return IntPtr.Zero;        }        private void Dispose(Boolean disposing)        {            if (disposing && (m_Mutex != null))            {                m_Mutex.ReleaseMutex();                m_Mutex.Close();                m_Mutex = null;            }        }        public void Dispose()        {            Dispose(true);            GC.SuppressFinalize(this);        }        #endregion        #region Methods: Overrides        protected override void OnStartup(StartupEventArgs e)        {            Assembly assembly = Assembly.GetExecutingAssembly();            Boolean mutexCreated;            String mutexName = String.Format(CultureInfo.InvariantCulture, Local\\{{{0}}}{{{1}}}, assembly.GetType().GUID, assembly.GetName().Name);            m_Mutex = new Mutex(true, mutexName, out mutexCreated);            m_Message = NativeMethods.RegisterWindowMessage(mutexName);            if (!mutexCreated)            {                m_Mutex = null;                NativeMethods.PostMessage(NativeMethods.HWND_BROADCAST, m_Message, IntPtr.Zero, IntPtr.Zero);                Current.Shutdown();                return;            }            base.OnStartup(e);            MainWindow window = new MainWindow();            MainWindow = window;            window.Show();             HwndSource.FromHwnd((new WindowInteropHelper(window)).Handle).AddHook(new HwndSourceHook(HandleMessages));        }        protected override void OnExit(ExitEventArgs e)        {            Dispose();            base.OnExit(e);        }        #endregion    }}Everything works perfectly... but I have some doubts about it and I would like to receive your suggestions about how my approach could be improved.I was asked by Code Analysis to implement IDisposable interface because I was using IDisposable members (the Mutex). Is my Dispose() implementation good enough? Should I avoid it because it's never going to be called?It's better to use m_Mutex = new Mutex(true, mutexName, out mutexCreated); and check for the result or to use m_Mutex = new Mutex(false, mutexName); and then check for m_Mutex.WaitOne(TimeSpan.Zero, false); ? In case of multithreading I mean... RegisterWindowMessage API call should return UInt32... but HwndSourceHook is only accepting Int32 as message value... should I be worried about unexpected behaviors (like a result bigger than Int32.MaxValue)?In OnStartup override... should I execute base.OnStartup(e); even if another instance is already running and I'm going to shutdown the application?Is there a better way to bring the existing instance to the top that doesn't need to set Topmost value? Maybe Activate()?Can you see any flaw in my approach? Something concerning multithreading, bad exceptions handling and something like that? For example... what happens if my application crashes between OnStartup and OnExit?
Single-instance WPF application
c#;singleton;wpf