C# 确保程序只有一个实例在运行[转]

In some scenarios, you may wishto ensure that a user can run only one instance of your application ata time. Besides ensuring that only a single instance of yourapplication is running, you may also want to bring the instance alreadyrunning to the front and restore it, if it is minimized.
First, toensure that only one instance of your application is running at a time,the best method I've found is to create a mutex that is held by theoperating system (thanks to Michael Covington). This will put a requestto the operating system that a mutex be created if one does not alreadyexist. Only one mutex can ever be created at a time, so if you requesta new one and it cannot be created, you can safely assume that yourapplication is already running.

using System.Threading
using System.Runtime.InteropServices;

public class Form1 : Form
{
[STAThread]
static void Main()
{
bool createdNew;

Mutex m = new Mutex(true, "YourAppName", out createdNew);

if (! createdNew)
{
// app is already running…
MessageBox.Show("Only one instance of this application is allowed at a time.");
return;
}

Application.Run(new Form1());

// keep the mutex reference alive until the normal termination of the program
GC.KeepAlive(m);
}
}

The above code will work for the vast majority of your needs. Itwill also run under scenarios where your code is executing with lessthan FullTrust permissions (see Code Access Security in MSDN forfurther information).

If your application can run with Full Trust permissions, we can takethis a step further and find the window of the application instnacealready running and bring it to the front for the user:

public class Form1 : Form
{
[STAThread]
static void Main()
{
bool createdNew;

System.Threading.Mutex m = new System.Threading.Mutex(true, "YourAppName", out createdNew);

if (! createdNew)
{
// see if we can find the other app and Bring it to front
IntPtr hWnd = FindWindow("WindowsForms10.Window.8.app3", "YourAppName");

if(hWnd != IntPtr.Zero)
{
Form1.WINDOWPLACEMENT placement = new Form1.WINDOWPLACEMENT();
placement.length = Marshal.SizeOf(placement);

GetWindowPlacement(hWnd, ref placement);

if(placement.showCmd != SW_NORMAL)
{
placement.showCmd = SW_RESTORE;

SetWindowPlacement(hWnd, ref placement);
SetForegroundWindow(hWnd);
}
}

return;
}

Application.Run(new Form1());

// keep the mutex reference alive until the normal termination of the program
GC.KeepAlive(m);
}

private const int SW_NORMAL = 1; // see WinUser.h for definitions
private const int SW_RESTORE = 9;

[DllImport("User32",EntryPoint="FindWindow")]
static extern IntPtr FindWindow(string className, string windowName);

[DllImport("User32",EntryPoint="SendMessage")]
private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

[DllImport("User32",EntryPoint="SetForegroundWindow")]
private static extern bool SetForegroundWindow(IntPtr hWnd);

[DllImport("User32",EntryPoint="SetWindowPlacement")]
private static extern bool SetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl);

[DllImport("User32",EntryPoint="GetWindowPlacement")]
private static extern bool GetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl);

private struct POINTAPI
{
public int x;
public int y;
}

private struct RECT
{
public int left;
public int top;
public int right;
public int bottom;
}

private struct WINDOWPLACEMENT
{
public int length;
public int flags;
public int showCmd;
public POINTAPI ptMinPosition;
public POINTAPI ptMaxPosition;
public RECT rcNormalPosition;
}
}

As you can see, with minimal effort, you can easily add a polishedtouch to your application. This might even help you avoid some extralegwork in ensuring that there are no issues with running multipleinstances of your app at the same time that you might have to address.

For more information about the Platform Invoke mechanisms to callWin32 API functions, I recommend that you check out .NET FrameworkSolutions: In Search of the Lost Win32 API by John Mueller and CharlesPetzold's seminal classic Programming Windows.

Until Longhorn comes out and more of the Windows platform becomesmanaged, platform invokes and interop will remain a key technology tounderstand and use to your advantage to fill the gaps left by theWindows Forms framework.

UPDATE:
Visual Studio .NET 2005 (aka. “Whidbey”) will let youspecify Single Instance behavior for Visual Basic .NET projects throughthe Project Properties page. Curious as to why this option is availablefor VB projects and not for C# projects, as this seems to instruct theruntime or some framework library not to load more than one instance.