単一インスタンスの WPF アプリケーションを作成する正しい方法は何ですか?
https://stackoverflow.com/questions/19147
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
.NET での C# と WPF の使用 ( Windows フォーム またはコンソール)、単一インスタンスとしてのみ実行できるアプリケーションを作成する正しい方法は何ですか?
それがミューテックスと呼ばれる神話的なものと関係があることはわかっていますが、ミューテックスが何であるかをわざわざ立ち止まって説明してくれる人はめったに見つかりません。
コードは、ユーザーが 2 番目のインスタンスを起動しようとしたことをすでに実行中のインスタンスに通知する必要があり、コマンドライン引数が存在する場合はそれを渡すことも必要です。
解決
ここはとても良いです 記事 Mutex ソリューションについて。この記事で説明されているアプローチには 2 つの理由があります。
まず、Microsoft.VisualBasic アセンブリへの依存関係が必要ありません。私のプロジェクトがすでにそのアセンブリに依存している場合、私はおそらく次のアプローチの使用を推奨するでしょう。 別の回答に示されています. 。しかし現状では、私は Microsoft.VisualBasic アセンブリを使用していません。また、プロジェクトに不必要な依存関係を追加したくありません。
次に、この記事では、ユーザーが別のインスタンスを起動しようとしたときに、アプリケーションの既存のインスタンスをフォアグラウンドに移動する方法を示します。これは、ここで説明する他の Mutex ソリューションでは対応していない非常に優れた点です。
アップデート
2014 年 8 月 1 日の時点で、上にリンクした記事はまだ有効ですが、ブログはしばらく更新されていません。そのため、最終的にはそれが消えてしまうのではないか、そしてそれとともに提唱されている解決策も消えてしまうのではないかと心配になります。後世のために記事の内容をここに転載します。この言葉はブログ所有者にのみ帰属します。 サニティフリーコーディング.
今日は、私のアプリケーションを禁止しているコードをリファクタリングしたかった。 それ自身の複数のインスタンスを実行することから。
以前に使用していました システム.診断.プロセス を検索する。 プロセスリストに私のmyapp.exeのインスタンスがある。これは機能するが 私はもっとクリーンなものが欲しかった。
このためにミューテックスを使うことができることは知っている（しかし使ったことはない 前略）私はコードを減らし、生活をシンプルにすることに着手した。
私のアプリケーションのメインのクラスで、という名前の静的ファイルを作成しました。 ミューテックス:
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
...
}
名前付きミューテックスを持つことで、同期を 複数のスレッドとプロセスは、まさに私が探しているマジックだ のためだ。
Mutex.WaitOne にはオーバーロードがあります。 を待つ。実際にコードを同期させたいわけではないので (現在使用中かどうかをチェックする）。 の2つのパラメータがある： Mutex.WaitOne(タイムスパン タイムアウト、ブール exitContext)。Wait は、入力できた場合は true を返し、入力できなかった場合は false を返します。この場合、まったく待ちたくないのです。ミューテックスが を使用し、それをスキップして次に進むので、TimeSpan.Zeroを渡す。 ミリ秒）を終了できるように、exitContextをtrueに設定する。 同期コンテキストのロックを取得しようとする前に。使用 この場合、Application.Runのコードを次のようにラップする：
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
static void Main() {
if(mutex.WaitOne(TimeSpan.Zero, true)) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
mutex.ReleaseMutex();
} else {
MessageBox.Show("only one instance at a time");
}
}
}
つまり、アプリが実行中であれば、WaitOneはfalseを返す。 メッセージボックス
メッセージボックスを表示する代わりに、Win32を少し利用して 実行中のインスタンスに、誰かがすでに実行中であることを忘れていたことを通知する。 を実行している（他のすべてのウィンドウの一番上に表示される）。へ これを実現するために 投稿メッセージ カスタムメッセージをすべての ウィンドウ（カスタムメッセージは ウィンドウメッセージの登録 つまり、私のアプリケーションだけが であるならば）、私の2番目のインスタンスは終了する。実行中のアプリケーション・インスタンス はその通知を受け取り、処理する。そのために オーバーライド WndProc をメインフォームに追加し、カスタムの を通知した。その通知を受け取ったとき、私はフォームの TopMostプロパティをtrueにすると、一番上に表示されます。
私が最終的に得たものは次のとおりです。
- プログラム.cs
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
static void Main() {
if(mutex.WaitOne(TimeSpan.Zero, true)) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
mutex.ReleaseMutex();
} else {
// send our Win32 message to make the currently running instance
// jump on top of all the other windows
NativeMethods.PostMessage(
(IntPtr)NativeMethods.HWND_BROADCAST,
NativeMethods.WM_SHOWME,
IntPtr.Zero,
IntPtr.Zero);
}
}
}
- NativeMethods.cs
// this class just wraps some Win32 stuff that we're going to use
internal 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")]
public static extern int RegisterWindowMessage(string message);
}
- Form1.cs (表面部分)
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
protected override void WndProc(ref Message m)
{
if(m.Msg == NativeMethods.WM_SHOWME) {
ShowMe();
}
base.WndProc(ref m);
}
private void ShowMe()
{
if(WindowState == FormWindowState.Minimized) {
WindowState = FormWindowState.Normal;
}
// get our current "TopMost" value (ours will always be false though)
bool top = TopMost;
// make our form jump to the top of everything
TopMost = true;
// set it back to whatever it was
TopMost = top;
}
}
他のヒント
Mutex クラスを使用することもできますが、引数などを渡すコードを自分で実装する必要があることがすぐにわかります。さて、読んだときに WinForms でプログラミングするときのコツを学びました。 クリス・セルの本. 。このトリックは、フレームワークですでに利用可能なロジックを使用します。あなたはどうか知りませんが、フレームワークで再利用できるものについて学ぶとき、私は通常、車輪の再発明ではなく、それを選択します。もちろん、それが私が望むすべてを実行するわけではない場合を除きます。
WPF を使い始めたとき、同じコードを WPF アプリケーションで使用する方法を思いつきました。このソリューションは、質問に基づいてニーズを満たすはずです。
まず、アプリケーション クラスを作成する必要があります。このクラスでは、OnStartup イベントをオーバーライドし、後で使用する Activate というメソッドを作成します。
public class SingleInstanceApplication : System.Windows.Application
{
protected override void OnStartup(System.Windows.StartupEventArgs e)
{
// Call the OnStartup event on our base class
base.OnStartup(e);
// Create our MainWindow and show it
MainWindow window = new MainWindow();
window.Show();
}
public void Activate()
{
// Reactivate the main window
MainWindow.Activate();
}
}
次に、インスタンスを管理できるクラスを作成する必要があります。その前に、実際に Microsoft.VisualBasic アセンブリにあるコードを再利用します。この例では C# を使用しているため、アセンブリへの参照を作成する必要がありました。VB.NET を使用している場合は、何もする必要はありません。使用するクラスは WindowsFormsApplicationBase で、そこからインスタンス マネージャーを継承し、プロパティとイベントを利用して単一のインスタンスを処理します。
public class SingleInstanceManager : Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase
{
private SingleInstanceApplication _application;
private System.Collections.ObjectModel.ReadOnlyCollection<string> _commandLine;
public SingleInstanceManager()
{
IsSingleInstance = true;
}
protected override bool OnStartup(Microsoft.VisualBasic.ApplicationServices.StartupEventArgs eventArgs)
{
// First time _application is launched
_commandLine = eventArgs.CommandLine;
_application = new SingleInstanceApplication();
_application.Run();
return false;
}
protected override void OnStartupNextInstance(StartupNextInstanceEventArgs eventArgs)
{
// Subsequent launches
base.OnStartupNextInstance(eventArgs);
_commandLine = eventArgs.CommandLine;
_application.Activate();
}
}
基本的に、VB ビットを使用して単一のインスタンスを検出し、それに応じて処理します。OnStartup は、最初のインスタンスがロードされるときに起動されます。OnStartupNextInstance は、アプリケーションが再度再実行されるときに起動されます。ご覧のとおり、コマンド ラインでイベント引数を介して渡された内容を取得できます。値をインスタンスフィールドに設定します。ここでコマンド ラインを解析することも、コンストラクターと Activate メソッドの呼び出しを通じてコマンド ラインをアプリケーションに渡すこともできます。
3 番目に、EntryPoint を作成します。通常のようにアプリケーションを新規作成する代わりに、SingleInstanceManager を利用します。
public class EntryPoint
{
[STAThread]
public static void Main(string[] args)
{
SingleInstanceManager manager = new SingleInstanceManager();
manager.Run(args);
}
}
すべてを理解して、この実装を使用して独自のものにできることを願っています。
から ここ.
クロスプロセス ミューテックスの一般的な用途は、一度にプログラムのインスタンスのみを実行できるようにすることです。その方法は次のとおりです。
class OneAtATimePlease {
// Use a name unique to the application (eg include your company URL)
static Mutex mutex = new Mutex (false, "oreilly.com OneAtATimeDemo");
static void Main()
{
// Wait 5 seconds if contended – in case another instance
// of the program is in the process of shutting down.
if (!mutex.WaitOne(TimeSpan.FromSeconds (5), false))
{
Console.WriteLine("Another instance of the app is running. Bye!");
return;
}
try
{
Console.WriteLine("Running - press Enter to exit");
Console.ReadLine();
}
finally
{
mutex.ReleaseMutex();
}
}
}
Mutex の優れた機能は、最初に ReleaseMutex を呼び出さずにアプリケーションが終了した場合、CLR が自動的に Mutex を解放することです。
実際、MSDN には、まさにこれを行うための C# と VB の両方のサンプル アプリケーションがあります。 http://msdn.microsoft.com/en-us/library/ms771662(v=VS.90).aspx
最も一般的で信頼性の高い手法 シングルインスタンス 検出は、Microsoft .NET フレームワーク・リモーティング・インフラストラクチャ (System.Remoting)です。マイクロソフトの.NET フレームワーク（バージョン2.0）には 型、WindowsFormsApplicationBase、 これは、必要な リモート機能。組み込む このタイプをWPFアプリケーションに組み込むには 型はそこから派生して、次のようになる必要がある。 アプリケーションの間のシムとして使用 静的エントリポイントメソッドであるMainと WPFアプリケーションのアプリケーション タイプだ。シムは アプリケーションが最初に起動され その後の打ち上げが をコントロールする。 アプリケーションの種類 打ち上げを処理する。
- C# の人は深呼吸して、「VisualBasic DLL を含めたくない」ということをすべて忘れてください。のため これ そして何 スコット・ハンセルマン 言う そして、これは問題に対する最もクリーンな解決策であり、あなたよりもフレームワークについてよく知っている人々によって設計されているという事実です。
- ユーザビリティの観点から見ると、実際には、ユーザーがアプリケーションをロードしていて、それがすでに開いていて、次のようなエラー メッセージが表示されることになります。
'Another instance of the app is running. Bye'そうなると、彼らはあまり幸せなユーザーにはなれないでしょう。(GUI アプリケーションでは) そのアプリケーションに切り替えて、指定された引数を渡す必要があります。または、コマンド ライン パラメータに意味がない場合は、最小化されたアプリケーションをポップアップする必要があります。
フレームワークはすでにこれをサポートしています - DLL という名前を付けた愚か者がいるだけです Microsoft.VisualBasic そしてそれは入れられませんでした Microsoft.ApplicationUtils とかそのようなもの。それを乗り越えるか、リフレクターを開いてください。
ヒント：このアプローチをそのまま使用し、リソースなどを含む App.xaml がすでにある場合。あなたはそうしたいでしょう これも見てください.
このコードは main メソッドに移動する必要があります。見る ここ WPF の main メソッドの詳細については、「WPF の main メソッドの詳細」を参照してください。
[DllImport("user32.dll")]
private static extern Boolean ShowWindow(IntPtr hWnd, Int32 nCmdShow);
private const int SW_SHOWMAXIMIZED = 3;
static void Main()
{
Process currentProcess = Process.GetCurrentProcess();
var runningProcess = (from process in Process.GetProcesses()
where
process.Id != currentProcess.Id &&
process.ProcessName.Equals(
currentProcess.ProcessName,
StringComparison.Ordinal)
select process).FirstOrDefault();
if (runningProcess != null)
{
ShowWindow(runningProcess.MainWindowHandle, SW_SHOWMAXIMIZED);
return;
}
}
方法 2
static void Main()
{
string procName = Process.GetCurrentProcess().ProcessName;
// get the list of all processes by that name
Process[] processes=Process.GetProcessesByName(procName);
if (processes.Length > 1)
{
MessageBox.Show(procName + " already running");
return;
}
else
{
// Application.Run(...);
}
}
注記 ： 上記の方法では、プロセス/アプリケーションが一意の名前を持つことを前提としています。プロセス名を使用して既存のプロセッサがあるかどうかを確認するためです。したがって、アプリケーションに非常に一般的な名前が付いている場合 (例:メモ帳)、上記のアプローチは機能しません。
そうですね、ほとんどのユースケースで簡単に機能する、これのための使い捨てクラスがあります。
次のように使用します。
static void Main()
{
using (SingleInstanceMutex sim = new SingleInstanceMutex())
{
if (sim.IsOtherInstanceRunning)
{
Application.Exit();
}
// Initialize program here.
}
}
ここにあります：
/// <summary>
/// Represents a <see cref="SingleInstanceMutex"/> class.
/// </summary>
public partial class SingleInstanceMutex : IDisposable
{
#region Fields
/// <summary>
/// Indicator whether another instance of this application is running or not.
/// </summary>
private bool isNoOtherInstanceRunning;
/// <summary>
/// The <see cref="Mutex"/> used to ask for other instances of this application.
/// </summary>
private Mutex singleInstanceMutex = null;
/// <summary>
/// An indicator whether this object is beeing actively disposed or not.
/// </summary>
private bool disposed;
#endregion
#region Constructor
/// <summary>
/// Initializes a new instance of the <see cref="SingleInstanceMutex"/> class.
/// </summary>
public SingleInstanceMutex()
{
this.singleInstanceMutex = new Mutex(true, Assembly.GetCallingAssembly().FullName, out this.isNoOtherInstanceRunning);
}
#endregion
#region Properties
/// <summary>
/// Gets an indicator whether another instance of the application is running or not.
/// </summary>
public bool IsOtherInstanceRunning
{
get
{
return !this.isNoOtherInstanceRunning;
}
}
#endregion
#region Methods
/// <summary>
/// Closes the <see cref="SingleInstanceMutex"/>.
/// </summary>
public void Close()
{
this.ThrowIfDisposed();
this.singleInstanceMutex.Close();
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool disposing)
{
if (!this.disposed)
{
/* Release unmanaged ressources */
if (disposing)
{
/* Release managed ressources */
this.Close();
}
this.disposed = true;
}
}
/// <summary>
/// Throws an exception if something is tried to be done with an already disposed object.
/// </summary>
/// <remarks>
/// All public methods of the class must first call this.
/// </remarks>
public void ThrowIfDisposed()
{
if (this.disposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
}
#endregion
}
Mutex と IPC のものを使用し、実行中のインスタンスにコマンド ライン引数を渡す新しいものは次のとおりです。 WPF 単一インスタンス アプリケーション.
コード C# .NET 単一インスタンス アプリケーション それはマークされた回答の参照であり、素晴らしいスタートです。
ただし、すでに存在するインスタンスでモーダル ダイアログが開いている場合、そのダイアログがマネージド ダイアログ (About ボックスなどの別のフォームなど) であっても、アンマネージド ダイアログ (標準の .NET クラスを使用している場合でも OpenFileDialog を使用します)。元のコードでは、メイン フォームはアクティブ化されますが、モーダル フォームは非アクティブなままであり、奇妙に見えます。さらに、アプリを使用し続けるにはユーザーがフォームをクリックする必要があります。
そこで、Winforms および WPF アプリケーション向けにこれらすべてを完全に自動的に処理する SingleInstance ユーティリティ クラスを作成しました。
Winforms:
1) Program クラスを次のように変更します。
static class Program
{
public static readonly SingleInstance Singleton = new SingleInstance(typeof(Program).FullName);
[STAThread]
static void Main(string[] args)
{
// NOTE: if this always return false, close & restart Visual Studio
// this is probably due to the vshost.exe thing
Singleton.RunFirstInstance(() =>
{
SingleInstanceMain(args);
});
}
public static void SingleInstanceMain(string[] args)
{
// standard code that was in Main now goes here
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
2) メイン ウィンドウ クラスを次のように変更します。
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
protected override void WndProc(ref Message m)
{
// if needed, the singleton will restore this window
Program.Singleton.OnWndProc(this, m, true);
// TODO: handle specific messages here if needed
base.WndProc(ref m);
}
}
WPF:
1) アプリ ページを次のように変更します (Main メソッドを再定義できるように、ビルド アクションをページに設定していることを確認してください)。
public partial class App : Application
{
public static readonly SingleInstance Singleton = new SingleInstance(typeof(App).FullName);
[STAThread]
public static void Main(string[] args)
{
// NOTE: if this always return false, close & restart Visual Studio
// this is probably due to the vshost.exe thing
Singleton.RunFirstInstance(() =>
{
SingleInstanceMain(args);
});
}
public static void SingleInstanceMain(string[] args)
{
// standard code that was in Main now goes here
App app = new App();
app.InitializeComponent();
app.Run();
}
}
2) メイン ウィンドウ クラスを次のように変更します。
public partial class MainWindow : Window
{
private HwndSource _source;
public MainWindow()
{
InitializeComponent();
}
protected override void OnSourceInitialized(EventArgs e)
{
base.OnSourceInitialized(e);
_source = (HwndSource)PresentationSource.FromVisual(this);
_source.AddHook(HwndSourceHook);
}
protected virtual IntPtr HwndSourceHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
// if needed, the singleton will restore this window
App.Singleton.OnWndProc(hwnd, msg, wParam, lParam, true, true);
// TODO: handle other specific message
return IntPtr.Zero;
}
そして、これがユーティリティクラスです:
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Threading;
namespace SingleInstanceUtilities
{
public sealed class SingleInstance
{
private const int HWND_BROADCAST = 0xFFFF;
[DllImport("user32.dll")]
private static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
private static extern int RegisterWindowMessage(string message);
[DllImport("user32.dll")]
private static extern bool SetForegroundWindow(IntPtr hWnd);
public SingleInstance(string uniqueName)
{
if (uniqueName == null)
throw new ArgumentNullException("uniqueName");
Mutex = new Mutex(true, uniqueName);
Message = RegisterWindowMessage("WM_" + uniqueName);
}
public Mutex Mutex { get; private set; }
public int Message { get; private set; }
public void RunFirstInstance(Action action)
{
RunFirstInstance(action, IntPtr.Zero, IntPtr.Zero);
}
// NOTE: if this always return false, close & restart Visual Studio
// this is probably due to the vshost.exe thing
public void RunFirstInstance(Action action, IntPtr wParam, IntPtr lParam)
{
if (action == null)
throw new ArgumentNullException("action");
if (WaitForMutext(wParam, lParam))
{
try
{
action();
}
finally
{
ReleaseMutex();
}
}
}
public static void ActivateWindow(IntPtr hwnd)
{
if (hwnd == IntPtr.Zero)
return;
FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(hwnd));
}
public void OnWndProc(IntPtr hwnd, int m, IntPtr wParam, IntPtr lParam, bool restorePlacement, bool activate)
{
if (m == Message)
{
if (restorePlacement)
{
WindowPlacement placement = WindowPlacement.GetPlacement(hwnd, false);
if (placement.IsValid && placement.IsMinimized)
{
const int SW_SHOWNORMAL = 1;
placement.ShowCmd = SW_SHOWNORMAL;
placement.SetPlacement(hwnd);
}
}
if (activate)
{
SetForegroundWindow(hwnd);
FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(hwnd));
}
}
}
#if WINFORMS // define this for Winforms apps
public void OnWndProc(System.Windows.Forms.Form form, int m, IntPtr wParam, IntPtr lParam, bool activate)
{
if (form == null)
throw new ArgumentNullException("form");
if (m == Message)
{
if (activate)
{
if (form.WindowState == System.Windows.Forms.FormWindowState.Minimized)
{
form.WindowState = System.Windows.Forms.FormWindowState.Normal;
}
form.Activate();
FormUtilities.ActivateWindow(FormUtilities.GetModalWindow(form.Handle));
}
}
}
public void OnWndProc(System.Windows.Forms.Form form, System.Windows.Forms.Message m, bool activate)
{
if (form == null)
throw new ArgumentNullException("form");
OnWndProc(form, m.Msg, m.WParam, m.LParam, activate);
}
#endif
public void ReleaseMutex()
{
Mutex.ReleaseMutex();
}
public bool WaitForMutext(bool force, IntPtr wParam, IntPtr lParam)
{
bool b = PrivateWaitForMutext(force);
if (!b)
{
PostMessage((IntPtr)HWND_BROADCAST, Message, wParam, lParam);
}
return b;
}
public bool WaitForMutext(IntPtr wParam, IntPtr lParam)
{
return WaitForMutext(false, wParam, lParam);
}
private bool PrivateWaitForMutext(bool force)
{
if (force)
return true;
try
{
return Mutex.WaitOne(TimeSpan.Zero, true);
}
catch (AbandonedMutexException)
{
return true;
}
}
}
// NOTE: don't add any field or public get/set property, as this must exactly map to Windows' WINDOWPLACEMENT structure
[StructLayout(LayoutKind.Sequential)]
public struct WindowPlacement
{
public int Length { get; set; }
public int Flags { get; set; }
public int ShowCmd { get; set; }
public int MinPositionX { get; set; }
public int MinPositionY { get; set; }
public int MaxPositionX { get; set; }
public int MaxPositionY { get; set; }
public int NormalPositionLeft { get; set; }
public int NormalPositionTop { get; set; }
public int NormalPositionRight { get; set; }
public int NormalPositionBottom { get; set; }
[DllImport("user32.dll", SetLastError = true)]
private static extern bool SetWindowPlacement(IntPtr hWnd, ref WindowPlacement lpwndpl);
[DllImport("user32.dll", SetLastError = true)]
private static extern bool GetWindowPlacement(IntPtr hWnd, ref WindowPlacement lpwndpl);
private const int SW_SHOWMINIMIZED = 2;
public bool IsMinimized
{
get
{
return ShowCmd == SW_SHOWMINIMIZED;
}
}
public bool IsValid
{
get
{
return Length == Marshal.SizeOf(typeof(WindowPlacement));
}
}
public void SetPlacement(IntPtr windowHandle)
{
SetWindowPlacement(windowHandle, ref this);
}
public static WindowPlacement GetPlacement(IntPtr windowHandle, bool throwOnError)
{
WindowPlacement placement = new WindowPlacement();
if (windowHandle == IntPtr.Zero)
return placement;
placement.Length = Marshal.SizeOf(typeof(WindowPlacement));
if (!GetWindowPlacement(windowHandle, ref placement))
{
if (throwOnError)
throw new Win32Exception(Marshal.GetLastWin32Error());
return new WindowPlacement();
}
return placement;
}
}
public static class FormUtilities
{
[DllImport("user32.dll")]
private static extern IntPtr GetWindow(IntPtr hWnd, int uCmd);
[DllImport("user32.dll", SetLastError = true)]
private static extern IntPtr SetActiveWindow(IntPtr hWnd);
[DllImport("user32.dll")]
private static extern bool IsWindowVisible(IntPtr hWnd);
[DllImport("kernel32.dll")]
public static extern int GetCurrentThreadId();
private delegate bool EnumChildrenCallback(IntPtr hwnd, IntPtr lParam);
[DllImport("user32.dll")]
private static extern bool EnumThreadWindows(int dwThreadId, EnumChildrenCallback lpEnumFunc, IntPtr lParam);
private class ModalWindowUtil
{
private const int GW_OWNER = 4;
private int _maxOwnershipLevel;
private IntPtr _maxOwnershipHandle;
private bool EnumChildren(IntPtr hwnd, IntPtr lParam)
{
int level = 1;
if (IsWindowVisible(hwnd) && IsOwned(lParam, hwnd, ref level))
{
if (level > _maxOwnershipLevel)
{
_maxOwnershipHandle = hwnd;
_maxOwnershipLevel = level;
}
}
return true;
}
private static bool IsOwned(IntPtr owner, IntPtr hwnd, ref int level)
{
IntPtr o = GetWindow(hwnd, GW_OWNER);
if (o == IntPtr.Zero)
return false;
if (o == owner)
return true;
level++;
return IsOwned(owner, o, ref level);
}
public static void ActivateWindow(IntPtr hwnd)
{
if (hwnd != IntPtr.Zero)
{
SetActiveWindow(hwnd);
}
}
public static IntPtr GetModalWindow(IntPtr owner)
{
ModalWindowUtil util = new ModalWindowUtil();
EnumThreadWindows(GetCurrentThreadId(), util.EnumChildren, owner);
return util._maxOwnershipHandle; // may be IntPtr.Zero
}
}
public static void ActivateWindow(IntPtr hwnd)
{
ModalWindowUtil.ActivateWindow(hwnd);
}
public static IntPtr GetModalWindow(IntPtr owner)
{
return ModalWindowUtil.GetModalWindow(owner);
}
}
}
以下は、アプリケーションの単一インスタンスを許可する例です。新しいインスタンスがロードされると、その引数が実行中のメイン インスタンスに渡されます。
public partial class App : Application
{
private static Mutex SingleMutex;
public static uint MessageId;
private void Application_Startup(object sender, StartupEventArgs e)
{
IntPtr Result;
IntPtr SendOk;
Win32.COPYDATASTRUCT CopyData;
string[] Args;
IntPtr CopyDataMem;
bool AllowMultipleInstances = false;
Args = Environment.GetCommandLineArgs();
// TODO: Replace {00000000-0000-0000-0000-000000000000} with your application's GUID
MessageId = Win32.RegisterWindowMessage("{00000000-0000-0000-0000-000000000000}");
SingleMutex = new Mutex(false, "AppName");
if ((AllowMultipleInstances) || (!AllowMultipleInstances && SingleMutex.WaitOne(1, true)))
{
new Main();
}
else if (Args.Length > 1)
{
foreach (Process Proc in Process.GetProcesses())
{
SendOk = Win32.SendMessageTimeout(Proc.MainWindowHandle, MessageId, IntPtr.Zero, IntPtr.Zero,
Win32.SendMessageTimeoutFlags.SMTO_BLOCK | Win32.SendMessageTimeoutFlags.SMTO_ABORTIFHUNG,
2000, out Result);
if (SendOk == IntPtr.Zero)
continue;
if ((uint)Result != MessageId)
continue;
CopyDataMem = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Win32.COPYDATASTRUCT)));
CopyData.dwData = IntPtr.Zero;
CopyData.cbData = Args[1].Length*2;
CopyData.lpData = Marshal.StringToHGlobalUni(Args[1]);
Marshal.StructureToPtr(CopyData, CopyDataMem, false);
Win32.SendMessageTimeout(Proc.MainWindowHandle, Win32.WM_COPYDATA, IntPtr.Zero, CopyDataMem,
Win32.SendMessageTimeoutFlags.SMTO_BLOCK | Win32.SendMessageTimeoutFlags.SMTO_ABORTIFHUNG,
5000, out Result);
Marshal.FreeHGlobal(CopyData.lpData);
Marshal.FreeHGlobal(CopyDataMem);
}
Shutdown(0);
}
}
}
public partial class Main : Window
{
private void Window_Loaded(object sender, RoutedEventArgs e)
{
HwndSource Source;
Source = HwndSource.FromHwnd(new WindowInteropHelper(this).Handle);
Source.AddHook(new HwndSourceHook(Window_Proc));
}
private IntPtr Window_Proc(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam, ref bool Handled)
{
Win32.COPYDATASTRUCT CopyData;
string Path;
if (Msg == Win32.WM_COPYDATA)
{
CopyData = (Win32.COPYDATASTRUCT)Marshal.PtrToStructure(lParam, typeof(Win32.COPYDATASTRUCT));
Path = Marshal.PtrToStringUni(CopyData.lpData, CopyData.cbData / 2);
if (WindowState == WindowState.Minimized)
{
// Restore window from tray
}
// Do whatever we want with information
Activate();
Focus();
}
if (Msg == App.MessageId)
{
Handled = true;
return new IntPtr(App.MessageId);
}
return IntPtr.Zero;
}
}
public class Win32
{
public const uint WM_COPYDATA = 0x004A;
public struct COPYDATASTRUCT
{
public IntPtr dwData;
public int cbData;
public IntPtr lpData;
}
[Flags]
public enum SendMessageTimeoutFlags : uint
{
SMTO_NORMAL = 0x0000,
SMTO_BLOCK = 0x0001,
SMTO_ABORTIFHUNG = 0x0002,
SMTO_NOTIMEOUTIFNOTHUNG = 0x0008
}
[DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
public static extern uint RegisterWindowMessage(string lpString);
[DllImport("user32.dll")]
public static extern IntPtr SendMessageTimeout(
IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam,
SendMessageTimeoutFlags fuFlags, uint uTimeout, out IntPtr lpdwResult);
}
ちょっと考えてみます:一部の人が信じているように、アプリケーションの 1 つのインスタンスだけが「不自由」ではないことを要求する場合があります。データベースアプリなど1 人のユーザーにアプリの複数のインスタンスがデータベースにアクセスできるようにすると、これは一桁難しくなります (ユーザーのマシン上のアプリの複数のインスタンスで開かれているすべてのレコードを更新することなど)。 。まず、「名前の衝突」については、人間が読める名前を使用しないでください。代わりに GUID を使用するか、できれば GUID + 人間が読める名前を使用してください。名前の衝突の可能性はレーダーから消えただけで、Mutex は気にしません。誰かが指摘したように、DOS 攻撃はひどいことになりますが、悪意のある人がわざわざミューテックス名を取得してアプリに組み込んだ場合、あなたはいずれにしてもかなりのターゲットとなり、自分自身を守るためにさらに多くのことを行う必要があります。単にミューテックス名を変更するだけではありません。また、次のバリアントを使用する場合:new Mutex(true, "some GUID plus Name", out AIsFirstInstance) の場合、Mutex が最初のインスタンスであるかどうかに関するインジケーターがすでにあります。
このような一見単純な質問に対する答えはたくさんあります。少しだけ状況を変えるために、この問題に対する私の解決策をここに示します。
Mutex の作成は面倒な場合があります。JIT er はコードのごく一部で Mutex を使用していることだけを認識し、それをガベージ コレクションの準備完了としてマークしようとするためです。それは、あなたがその Mutex をそれほど長くは使用しないだろうと考えているあなたを出し抜こうとしているのです。実際には、アプリケーションが実行されている限り、この Mutex にハングアップする必要があります。Mutex を放っておくようにガベージ コレクターに指示する最善の方法は、異なる世代のガレージ コレクションを通じて Mutex を存続させるように指示することです。例：
var m = new Mutex(...);
...
GC.KeepAlive(m);
このページからアイデアを引用しました。 http://www.ai.uga.edu/~mc/SingleInstance.html
これを処理する非常に良い方法があるようです。
これにより、すべてのミューテックスとメッセージングの要点を管理する追加クラスが提供され、実装が簡単になるまで簡素化されます。
次のコードは、単一インスタンスのアプリケーションを登録するための WCF 名前付きパイプ ソリューションです。別のインスタンスが起動しようとしたときにイベントが発生し、他のインスタンスのコマンド ラインを受信するので、これは便利です。
を使用するため、WPF を対象としています。 System.Windows.StartupEventHandler クラスですが、これは簡単に変更できます。
このコードにはへの参照が必要です PresentationFramework, 、 そして System.ServiceModel.
使用法：
class Program
{
static void Main()
{
var applicationId = new Guid("b54f7b0d-87f9-4df9-9686-4d8fd76066dc");
if (SingleInstanceManager.VerifySingleInstance(applicationId))
{
SingleInstanceManager.OtherInstanceStarted += OnOtherInstanceStarted;
// Start the application
}
}
static void OnOtherInstanceStarted(object sender, StartupEventArgs e)
{
// Do something in response to another instance starting up.
}
}
ソースコード：
/// <summary>
/// A class to use for single-instance applications.
/// </summary>
public static class SingleInstanceManager
{
/// <summary>
/// Raised when another instance attempts to start up.
/// </summary>
public static event StartupEventHandler OtherInstanceStarted;
/// <summary>
/// Checks to see if this instance is the first instance running on this machine. If it is not, this method will
/// send the main instance this instance's startup information.
/// </summary>
/// <param name="guid">The application's unique identifier.</param>
/// <returns>True if this instance is the main instance.</returns>
public static bool VerifySingleInstace(Guid guid)
{
if (!AttemptPublishService(guid))
{
NotifyMainInstance(guid);
return false;
}
return true;
}
/// <summary>
/// Attempts to publish the service.
/// </summary>
/// <param name="guid">The application's unique identifier.</param>
/// <returns>True if the service was published successfully.</returns>
private static bool AttemptPublishService(Guid guid)
{
try
{
ServiceHost serviceHost = new ServiceHost(typeof(SingleInstance));
NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
serviceHost.AddServiceEndpoint(typeof(ISingleInstance), binding, CreateAddress(guid));
serviceHost.Open();
return true;
}
catch
{
return false;
}
}
/// <summary>
/// Notifies the main instance that this instance is attempting to start up.
/// </summary>
/// <param name="guid">The application's unique identifier.</param>
private static void NotifyMainInstance(Guid guid)
{
NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
EndpointAddress remoteAddress = new EndpointAddress(CreateAddress(guid));
using (ChannelFactory<ISingleInstance> factory = new ChannelFactory<ISingleInstance>(binding, remoteAddress))
{
ISingleInstance singleInstance = factory.CreateChannel();
singleInstance.NotifyMainInstance(Environment.GetCommandLineArgs());
}
}
/// <summary>
/// Creates an address to publish/contact the service at based on a globally unique identifier.
/// </summary>
/// <param name="guid">The identifier for the application.</param>
/// <returns>The address to publish/contact the service.</returns>
private static string CreateAddress(Guid guid)
{
return string.Format(CultureInfo.CurrentCulture, "net.pipe://localhost/{0}", guid);
}
/// <summary>
/// The interface that describes the single instance service.
/// </summary>
[ServiceContract]
private interface ISingleInstance
{
/// <summary>
/// Notifies the main instance that another instance of the application attempted to start.
/// </summary>
/// <param name="args">The other instance's command-line arguments.</param>
[OperationContract]
void NotifyMainInstance(string[] args);
}
/// <summary>
/// The implementation of the single instance service interface.
/// </summary>
private class SingleInstance : ISingleInstance
{
/// <summary>
/// Notifies the main instance that another instance of the application attempted to start.
/// </summary>
/// <param name="args">The other instance's command-line arguments.</param>
public void NotifyMainInstance(string[] args)
{
if (OtherInstanceStarted != null)
{
Type type = typeof(StartupEventArgs);
ConstructorInfo constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
StartupEventArgs e = (StartupEventArgs)constructor.Invoke(null);
FieldInfo argsField = type.GetField("_args", BindingFlags.Instance | BindingFlags.NonPublic);
Debug.Assert(argsField != null);
argsField.SetValue(e, args);
OtherInstanceStarted(null, e);
}
}
}
}
名前付きミューテックスを単一インスタンス アプリケーションの実装に使用しないでください (少なくとも実稼働コードでは使用しないでください)。悪意のあるコードは簡単に DoS を実行できます (サービス拒否) あなたのお尻...
これが私が使っているものです。プロセスの列挙を組み合わせてスイッチングを実行し、ミューテックスを組み合わせて「アクティブ クリッカー」から保護します。
public partial class App
{
[DllImport("user32")]
private static extern int OpenIcon(IntPtr hWnd);
[DllImport("user32.dll")]
private static extern bool SetForegroundWindow(IntPtr hWnd);
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var p = Process
.GetProcessesByName(Process.GetCurrentProcess().ProcessName);
foreach (var t in p.Where(t => t.MainWindowHandle != IntPtr.Zero))
{
OpenIcon(t.MainWindowHandle);
SetForegroundWindow(t.MainWindowHandle);
Current.Shutdown();
return;
}
// there is a chance the user tries to click on the icon repeatedly
// and the process cannot be discovered yet
bool createdNew;
var mutex = new Mutex(true, "MyAwesomeApp",
out createdNew); // must be a variable, though it is unused -
// we just need a bit of time until the process shows up
if (!createdNew)
{
Current.Shutdown();
return;
}
new Bootstrapper().Run();
}
}
私は、Dale Ragan のものと似ていますが、少し変更された、より単純な解決策を見つけました。これは、標準の Microsoft WindowsFormsApplicationBase クラスに基づいて、必要な機能を実質的にすべて実行します。
まず、SingleInstanceController クラスを作成します。これは、Windows フォームを使用する他のすべての単一インスタンス アプリケーションで使用できます。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.VisualBasic.ApplicationServices;
namespace SingleInstanceController_NET
{
public class SingleInstanceController
: WindowsFormsApplicationBase
{
public delegate Form CreateMainForm();
public delegate void StartNextInstanceDelegate(Form mainWindow);
CreateMainForm formCreation;
StartNextInstanceDelegate onStartNextInstance;
public SingleInstanceController(CreateMainForm formCreation, StartNextInstanceDelegate onStartNextInstance)
{
// Set whether the application is single instance
this.formCreation = formCreation;
this.onStartNextInstance = onStartNextInstance;
this.IsSingleInstance = true;
this.StartupNextInstance += new StartupNextInstanceEventHandler(this_StartupNextInstance);
}
void this_StartupNextInstance(object sender, StartupNextInstanceEventArgs e)
{
if (onStartNextInstance != null)
{
onStartNextInstance(this.MainForm); // This code will be executed when the user tries to start the running program again,
// for example, by clicking on the exe file.
} // This code can determine how to re-activate the existing main window of the running application.
}
protected override void OnCreateMainForm()
{
// Instantiate your main application form
this.MainForm = formCreation();
}
public void Run()
{
string[] commandLine = new string[0];
base.Run(commandLine);
}
}
}
その後、次のようにプログラムでそれを使用できます。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using SingleInstanceController_NET;
namespace SingleInstance
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
static Form CreateForm()
{
return new Form1(); // Form1 is used for the main window.
}
static void OnStartNextInstance(Form mainWindow) // When the user tries to restart the application again,
// the main window is activated again.
{
mainWindow.WindowState = FormWindowState.Maximized;
}
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
SingleInstanceController controller = new SingleInstanceController(CreateForm, OnStartNextInstance);
controller.Run();
}
}
}
プログラムと SingleInstanceController_NET ソリューションの両方で Microsoft.VisualBasic を参照する必要があります。ユーザーが実行中のプログラムを再起動しようとしたときに、実行中のアプリケーションを通常のウィンドウとして再アクティブ化するだけの場合は、SingleInstanceController の 2 番目のパラメータを null にすることができます。この例では、ウィンドウが最大化されています。
次のコードを見てください。これは、WPF アプリケーションの複数のインスタンスを防ぐための優れたシンプルなソリューションです。
private void Application_Startup(object sender, StartupEventArgs e)
{
Process thisProc = Process.GetCurrentProcess();
if (Process.GetProcessesByName(thisProc.ProcessName).Length > 1)
{
MessageBox.Show("Application running");
Application.Current.Shutdown();
return;
}
var wLogin = new LoginWindow();
if (wLogin.ShowDialog() == true)
{
var wMain = new Main();
wMain.WindowState = WindowState.Maximized;
wMain.Show();
}
else
{
Application.Current.Shutdown();
}
}
ただし、Mutex は使用していません。簡単な答えは次のとおりです。
System.Diagnostics;
...
string thisprocessname = Process.GetCurrentProcess().ProcessName;
if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
return;
中に入れてください Program.Main().
例:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Diagnostics;
namespace Sample
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
//simple add Diagnostics namespace, and these 3 lines below
string thisprocessname = Process.GetCurrentProcess().ProcessName;
if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
return;
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Sample());
}
}
}
あなたは付け加えられます MessageBox.Show に if-ステートメントを追加し、「アプリケーションはすでに実行中」と入力します。
これは誰かの役に立つかもしれません。
2017 年 1 月 25 日更新。 いくつか試した結果、VisualBasic.dll を使用することにしました。VisualBasic.dll の方が簡単で、動作も優れています (少なくとも私にとっては)。前回の回答を参考にさせていただきます...
参考までに、これは私が引数を渡さずに実行した方法です（そうする理由は見つかりません...）あるインスタンスから別のインスタンスに渡される引数を持つ単一のアプリを意味します。ファイルの関連付けが必要な場合は、(ユーザーの標準的な期待に従って) ドキュメントごとにアプリをインスタンス化する必要があります。既存のアプリに引数を渡す必要がある場合は、vb dll を使用すると思います。
引数を渡さないので（単一インスタンスのアプリのみ）、新しいウィンドウメッセージを登録せず、マットデイビスソリューションで定義されているメッセージループをオーバーライドしないことを好みます。VisualBasic DLL を追加するのは大したことではありませんが、単一インスタンスのアプリを実行するためだけに新しい参照を追加することは避けたいと考えています。また、できるだけ早く終了できるように、App.Startup オーバーライドから Shutdown を呼び出すのではなく、Main で新しいクラスをインスタンス化することを好みます。
どなたでも気に入っていただければ幸いです...または、少しインスピレーションを与えるでしょう:-)
プロジェクトのスタートアップ クラスは「SingleInstanceApp」として設定する必要があります。
public class SingleInstanceApp
{
[STAThread]
public static void Main(string[] args)
{
Mutex _mutexSingleInstance = new Mutex(true, "MonitorMeSingleInstance");
if (_mutexSingleInstance.WaitOne(TimeSpan.Zero, true))
{
try
{
var app = new App();
app.InitializeComponent();
app.Run();
}
finally
{
_mutexSingleInstance.ReleaseMutex();
_mutexSingleInstance.Close();
}
}
else
{
MessageBox.Show("One instance is already running.");
var processes = Process.GetProcessesByName(Assembly.GetEntryAssembly().GetName().Name);
{
if (processes.Length > 1)
{
foreach (var process in processes)
{
if (process.Id != Process.GetCurrentProcess().Id)
{
WindowHelper.SetForegroundWindow(process.MainWindowHandle);
}
}
}
}
}
}
}
ウィンドウヘルパー:
using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Threading;
namespace HQ.Util.Unmanaged
{
public class WindowHelper
{
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetForegroundWindow(IntPtr hWnd);
ミューテックス ソリューションを使用します。
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;
}
}
}
}
}
これは、私が使用している軽量のソリューションです。これにより、アプリケーションは、カスタム ウィンドウ メッセージに頼ったり、プロセス名を盲目的に検索したりせずに、既存のウィンドウを最前面に表示できます。
[DllImport("user32.dll")]
static extern bool SetForegroundWindow(IntPtr hWnd);
static readonly string guid = "<Application Guid>";
static void Main()
{
Mutex mutex = null;
if (!CreateMutex(out mutex))
return;
// Application startup code.
Environment.SetEnvironmentVariable(guid, null, EnvironmentVariableTarget.User);
}
static bool CreateMutex(out Mutex mutex)
{
bool createdNew = false;
mutex = new Mutex(false, guid, out createdNew);
if (createdNew)
{
Process process = Process.GetCurrentProcess();
string value = process.Id.ToString();
Environment.SetEnvironmentVariable(guid, value, EnvironmentVariableTarget.User);
}
else
{
string value = Environment.GetEnvironmentVariable(guid, EnvironmentVariableTarget.User);
Process process = null;
int processId = -1;
if (int.TryParse(value, out processId))
process = Process.GetProcessById(processId);
if (process == null || !SetForegroundWindow(process.MainWindowHandle))
MessageBox.Show("Unable to start application. An instance of this application is already running.");
}
return createdNew;
}
編集：ミューテックスと createdNew を静的に保存して初期化することもできますが、使用が完了したら、ミューテックスを明示的に破棄/解放する必要があります。個人的には、Main の最後に到達することなくアプリケーションが閉じられた場合でもミューテックスは自動的に破棄されるため、ミューテックスをローカルに保持することを好みます。
を使用することもできます。 CodeFluent ランタイム これは無料のツールセットです。それは、 単一インスタンス 単一インスタンスのアプリケーションを実装するクラス。
これは同じものを Event 経由で実装したものです。
public enum ApplicationSingleInstanceMode
{
CurrentUserSession,
AllSessionsOfCurrentUser,
Pc
}
public class ApplicationSingleInstancePerUser: IDisposable
{
private readonly EventWaitHandle _event;
/// <summary>
/// Shows if the current instance of ghost is the first
/// </summary>
public bool FirstInstance { get; private set; }
/// <summary>
/// Initializes
/// </summary>
/// <param name="applicationName">The application name</param>
/// <param name="mode">The single mode</param>
public ApplicationSingleInstancePerUser(string applicationName, ApplicationSingleInstanceMode mode = ApplicationSingleInstanceMode.CurrentUserSession)
{
string name;
if (mode == ApplicationSingleInstanceMode.CurrentUserSession)
name = $"Local\\{applicationName}";
else if (mode == ApplicationSingleInstanceMode.AllSessionsOfCurrentUser)
name = $"Global\\{applicationName}{Environment.UserDomainName}";
else
name = $"Global\\{applicationName}";
try
{
bool created;
_event = new EventWaitHandle(false, EventResetMode.ManualReset, name, out created);
FirstInstance = created;
}
catch
{
}
}
public void Dispose()
{
_event.Dispose();
}
}
名前付きミューテックスは Mono ではグローバルではないため、名前付きミューテックス ベースのアプローチはクロスプラットフォームではありません。プロセス列挙ベースのアプローチには同期がないため、誤った動作が発生する可能性があります (例:複数のプロセスを同時に起動した場合、タイミングによってはすべて自己終了する場合があります。)ウィンドウ システム ベースのアプローチは、コンソール アプリケーションでは望ましくありません。このソリューションは、Divin の回答に基づいて構築されており、これらすべての問題に対処します。
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.");
}
}
}
}
見つからない 短い解決策 ここで誰かがこれを気に入ってくれることを願っています:
2018-09-20更新
（ところで。コードを入力してください 「プログラム.cs」)
using System.Diagnostics;
static void Main()
{
Process ThisProcess = Process.GetCurrentProcess();
Process[] AllProcesses = Process.GetProcessesByName(ThisProcess.ProcessName);
if (AllProcesses.Length > 1)
{
//Don't put a MessageBox in here because the user could spam this MessageBox.
return;
}
// オプションのコード。誰かに実行されたくない場合は、別の名前の「.exe」を使用します。
string exeName = AppDomain.CurrentDomain.FriendlyName;
if (exeName != "the name of you're executable.exe") // If you try that in debug mode, don't forget that u don't use ur normal .exe. Debug uses the .vshost.exe.
{// You can add here a MessageBox if you want. To point users that the name got changed and maybe what the name should be or something like that^^
MessageBox.Show("The executable name should be \"the name of you're executable.exe\"",
"Wrong executable name", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
//Following Code is default code:
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
NativeMethods クラスに sendMessage メソッドを追加しました。
アプリケーションがタスクバーに表示されていない場合、postmessage メソッドは機能しないようですが、sendmessage メソッドを使用するとこれが解決されます。
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);
}
通常、.exe を実行するたびに、独自のアドレス空間やリソースなどを持つ別の Windows プロセスが作成されます。ただし、単一のプロセスを作成できなくなるため、この基準は必要ありません。単一インスタンスのアプリケーションは、C# の Mutex を使用して作成できます。 この記事で説明されています
さらに、アプリケーションを最上位に持って行きたい場合は、次を使用してそれを行うことができます
[DllImport("user32")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);
通常、これは単一インスタンスに使用するコードです Windows フォーム アプリケーション:
[STAThread]
public static void Main()
{
String assemblyName = Assembly.GetExecutingAssembly().GetName().Name;
using (Mutex mutex = new Mutex(false, assemblyName))
{
if (!mutex.WaitOne(0, false))
{
Boolean shownProcess = false;
Process currentProcess = Process.GetCurrentProcess();
foreach (Process process in Process.GetProcessesByName(currentProcess.ProcessName))
{
if (!process.Id.Equals(currentProcess.Id) && process.MainModule.FileName.Equals(currentProcess.MainModule.FileName) && !process.MainWindowHandle.Equals(IntPtr.Zero))
{
IntPtr windowHandle = process.MainWindowHandle;
if (NativeMethods.IsIconic(windowHandle))
NativeMethods.ShowWindow(windowHandle, ShowWindowCommand.Restore);
NativeMethods.SetForegroundWindow(windowHandle);
shownProcess = true;
}
}
if (!shownProcess)
MessageBox.Show(String.Format(CultureInfo.CurrentCulture, "An instance of {0} is already running!", assemblyName), assemblyName, MessageBoxButtons.OK, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button1, (MessageBoxOptions)0);
}
else
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form());
}
}
}
ネイティブコンポーネントは次のとおりです。
[DllImport("User32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern Boolean IsIconic([In] IntPtr windowHandle);
[DllImport("User32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern Boolean SetForegroundWindow([In] IntPtr windowHandle);
[DllImport("User32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
internal static extern Boolean ShowWindow([In] IntPtr windowHandle, [In] ShowWindowCommand command);
public enum ShowWindowCommand : int
{
Hide = 0x0,
ShowNormal = 0x1,
ShowMinimized = 0x2,
ShowMaximized = 0x3,
ShowNormalNotActive = 0x4,
Minimize = 0x6,
ShowMinimizedNotActive = 0x7,
ShowCurrentNotActive = 0x8,
Restore = 0x9,
ShowDefault = 0xA,
ForceMinimize = 0xB
}
解決策は次のとおりです。
Protected Overrides Sub OnStartup(e As StartupEventArgs)
Const appName As String = "TestApp"
Dim createdNew As Boolean
_mutex = New Mutex(True, appName, createdNew)
If Not createdNew Then
'app is already running! Exiting the application
MessageBox.Show("Application is already running.")
Application.Current.Shutdown()
End If
MyBase.OnStartup(e)
End Sub
こうして私はこの問題に対処することになりました。デバッグ コードがテスト用にまだ存在していることに注意してください。このコードは、App.xaml.cs ファイルの OnStartup 内にあります。(WPF)
// Process already running ?
if (Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName).Length > 1)
{
// Show your error message
MessageBox.Show("xxx is already running. \r\n\r\nIf the original process is hung up you may need to restart your computer, or kill the current xxx process using the task manager.", "xxx is already running!", MessageBoxButton.OK, MessageBoxImage.Exclamation);
// This process
Process currentProcess = Process.GetCurrentProcess();
// Get all processes running on the local computer.
Process[] localAll = Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName);
// ID of this process...
int temp = currentProcess.Id;
MessageBox.Show("This Process ID: " + temp.ToString());
for (int i = 0; i < localAll.Length; i++)
{
// Find the other process
if (localAll[i].Id != currentProcess.Id)
{
MessageBox.Show("Original Process ID (Switching to): " + localAll[i].Id.ToString());
// Switch to it...
SetForegroundWindow(localAll[i].MainWindowHandle);
}
}
Application.Current.Shutdown();
}
これには私がまだ気づいていない問題があるかもしれません。何かに遭遇した場合は、回答を更新します。
所属していません StackOverflow
