zlb

WPF程序只有一个实例运行

WPF程序只运行一个实例;

下面的代码还 尝试,如果窗体最小化的时候,让窗体还原

public partial class App : Application
   {
       private static Semaphore singleInstanceWatcher;
       private static bool createdNew;
 
       static App()
       {
           // Ensure other instances of this application are not running.
           singleInstanceWatcher = new Semaphore(
               0, // Initial count.
               1, // Maximum count.
               Assembly.GetExecutingAssembly().GetName().Name,
               out createdNew);
 
           if (createdNew)
           {
               // This thread created the kernel object so no other instance
               // of this application must be running.
               //Application currApp = Application.Current;
               //currApp.StartupUri = new Uri("MainWindow.xaml", UriKind.RelativeOrAbsolute);
               MainWindow win = new MainWindow();
               win.Show();
           }
           else
           {
               // This thread opened an existing kernel object with the same
               // string name; another instance of this app must be running now.
               // Gets a new System.Diagnostics.Process component and the
               // associates it with currently active process.
               Process current = Process.GetCurrentProcess();
 
               // Enumerate through all the process resources on the share
               // local computer that the specified process name.
               foreach (Process process in
                    Process.GetProcessesByName(current.ProcessName))
               {
                   if (process.Id != current.Id)
                   {
                       NativeMethods.SetForegroundWindow(
                           process.MainWindowHandle);
                       NativeMethods.ShowWindow(process.MainWindowHandle,
                           WindowShowStyle.Restore);
                       break;
                   }
               }
 
               // Terminate this process and gives the underlying operating 
               // system the specified exit code.
               Environment.Exit(-2);
           }
 
 // 如果代码在Application_Startup中 如下
       // private Semaphore singleInstanceWatcher;
         // private bool createdNew;
           
//private void Application_Startup(object sender, StartupEventArgs e)
           //{
           //    singleInstanceWatcher = new Semaphore(
           //   0, // Initial count.
           //   1, // Maximum count.
           //   Assembly.GetExecutingAssembly().GetName().Name,
           //   out createdNew);
           //    if (createdNew)
           //    {
           //        // This thread created the kernel object so no other instance
           //        // of this application must be running.
           //        Application currApp = Application.Current;
           //        currApp.StartupUri = new Uri("MainWindow.xaml", UriKind.RelativeOrAbsolute);
           //    }
           //    else
           //    {
           //        //MessageBox.Show("系统已经运行");
           //        Process current = Process.GetCurrentProcess();
           //        foreach (Process process in
           //             Process.GetProcessesByName(current.ProcessName))
           //        {
           //            if (process.Id != current.Id)
           //            {
                           
           //                NativeMethods.SetForegroundWindow(
           //                    process.MainWindowHandle);
           //                NativeMethods.ShowWindow(process.MainWindowHandle,
           //                    WindowShowStyle.Restore);
           //                break;
           //            }
           //        }
           //        Environment.Exit(-2);
           //    }
          
}
   }
       internal enum WindowShowStyle : uint
       {
           /// <summary>Hides the window and activates another window.</summary>
           /// <remarks>See SW_HIDE</remarks>
           Hide = 0,
           /// <summary>Activates and displays a window. If the window ..
           /// or maximized, the system restores it to its original size and
           /// position. An application should specify this flag when displaying
           /// the window for the first time.</summary>
           /// <remarks>See SW_SHOWNORMAL</remarks>
           ShowNormal = 1,
           /// <summary>Activates the window and displays it ..</summary>
           /// <remarks>See SW_SHOWMINIMIZED</remarks>
           ShowMinimized = 2,
           /// <summary>Activates the window and displays it ..</summary>
           /// <remarks>See SW_SHOWMAXIMIZED</remarks>
           ShowMaximized = 3,
           /// <summary>Maximizes the specified window.</summary>
           /// <remarks>See SW_MAXIMIZE</remarks>
           Maximize = 3,
           /// <summary>Displays a window in its most recent size and position.
           /// This value is similar to "ShowNormal", except the window is not
           /// actived.</summary>
           /// <remarks>See SW_SHOWNOACTIVATE</remarks>
           ShowNormalNoActivate = 4,
           /// <summary>Activates the window and displays it in its current size
           /// and position.</summary>
           /// <remarks>See SW_SHOW</remarks>
           Show = 5,
           /// <summary>Minimizes the specified window and activates the next
           /// top-level window in the Z order.</summary>
           /// <remarks>See SW_MINIMIZE</remarks>
           Minimize = 6,
           /// <summary>Displays the window as a minimized window. This value is
           /// similar to "ShowMinimized", except the window ..</summary>
           /// <remarks>See SW_SHOWMINNOACTIVE</remarks>
           ShowMinNoActivate = 7,
           /// <summary>Displays the window in its current size and position. This
           /// value is similar to "Show", except the window ..</summary>
           /// <remarks>See SW_SHOWNA</remarks>
           ShowNoActivate = 8,
           /// <summary>Activates and displays the window. If the window is
           /// minimized or maximized, the system restores it to its original size
           /// and position. An application should specify this flag ..
           /// a minimized window.</summary>
           /// <remarks>See SW_RESTORE</remarks>
           Restore = 9,
           /// <summary>Sets the show state based on the SW_ value specified ..
           /// STARTUPINFO structure passed to the CreateProcess function by the
           /// program that started the application.</summary>
           /// <remarks>See SW_SHOWDEFAULT</remarks>
           ShowDefault = 10,
           /// <summary>Windows 2000/XP: Minimizes a window, even if the thread
           /// that owns the window is hung. This flag should only be used when
           /// minimizing windows from a different thread.</summary>
           /// <remarks>See SW_FORCEMINIMIZE</remarks>
           ForceMinimized = 11
       }
       static class NativeMethods
       {
           /// <summary>
           /// Brings the thread that created the specified window into the
           /// foreground and activates the window. Keyboard input is directed
           /// to the window, and various visual cues are changed for the user.
           /// The system assigns a slightly higher priority to the thread that
           /// created the foreground window than it does to other threads.
           /// </summary>
           /// <param name="hWnd">A handle to the window that should be
           /// activated and brought to the foreground.
           /// </param>
           /// <returns>If the window was brought to the foreground, the
           /// return value is nonzero. </returns>
           [DllImport("user32.dll")]
           internal static extern bool SetForegroundWindow(IntPtr hWnd);
 
           /// <summary>Shows a Window</summary>
           /// <remarks>
           /// <para>To perform certain special effects when showing or hiding a
           /// window, use AnimateWindow.</para>
           /// <para>The first time an application calls ShowWindow, it should use
           /// the WinMain function's nCmdShow parameter as its nCmdShow ..
           /// Subsequent calls to ShowWindow must use one of the values in the
           /// given list, instead of the one specified by the WinMain function's
           /// nCmdShow parameter.</para>
           /// <para>As noted in the discussion of the nCmdShow parameter, the
           /// nCmdShow value is ignored in the first call to ShowWindow if the
           /// program that launched the application specifies startup information
           /// in the structure. In this case, ShowWindow uses the information
           /// specified in the STARTUPINFO structure to show the window. On
           /// subsequent calls, the application must call ShowWindow with ..
           /// set to SW_SHOWDEFAULT to use the startup information provided by ..
           /// program that launched the application. This behavior is designed ..
           /// the following situations: </para>
           /// <list type="">
           ///    <item>Applications create their main window by calling ..
           ///    with the WS_VISIBLE flag set. </item>
           ///    <item>Applications create their main window by calling ..
           ///    with the WS_VISIBLE flag cleared, and later call ShowWindow ..
           ///    SW_SHOW flag set to make it visible.</item>
           /// </list></remarks>
           /// <param name="hWnd">Handle to the window.</param>
           /// <param name="nCmdShow">Specifies how the window is to be shown.
           /// This parameter is ignored the first time an application calls
           /// ShowWindow, if the program that launched the application provides a
           /// STARTUPINFO structure. Otherwise, the first time ShowWindow .. ,
           /// the value should be the value obtained by the WinMain function ..
           /// nCmdShow parameter. In subsequent calls, this parameter ..
           /// the WindowShowStyle members.</param>
           /// <returns>
           /// If the window was previously visible, the return value is nonzero.
           /// If the window was previously hidden, the return value is zero.
           /// </returns>
           [DllImport("user32.dll")]
           internal static extern bool ShowWindow(IntPtr hWnd,
               WindowShowStyle nCmdShow);
       }
 

posted on 2012-09-16 14:16  zlb  阅读(2491)  评论(0编辑  收藏  举报

导航