[C#] 단일 인스턴스 WPF 애플리케이션을 작성하는 올바른 방법은 무엇입니까?

다음은 Mutex 솔루션에 관한 매우 유용한 기사 입니다. 이 기사에서 설명하는 접근 방식은 두 가지 이유로 유리합니다.

먼저 Microsoft.VisualBasic 어셈블리에 대한 종속성이 필요하지 않습니다. 내 프로젝트가 이미 해당 어셈블리에 종속되어 있다면 다른 답변에 표시된 접근법을 사용하여 옹호 할 것입니다 . 그러나 그대로 Microsoft.VisualBasic 어셈블리를 사용하지 않고 프로젝트에 불필요한 종속성을 추가하지 않습니다.

둘째,이 기사에서는 사용자가 다른 인스턴스를 시작하려고 할 때 응용 프로그램의 기존 인스턴스를 포 그라운드로 가져 오는 방법을 보여줍니다. 그것은 여기에 설명 된 다른 Mutex 솔루션이 다루지 않는 매우 좋은 터치입니다.

최신 정보

2014 년 8 월 1 일 현재, 위에 링크 된 기사는 여전히 활성화되어 있지만 블로그는 한동안 업데이트되지 않았습니다. 그것은 결국 그것이 사라지고 옹호 된 해결책이 될지 걱정합니다. 나는 후손을 위해 기사의 내용을 재현하고 있습니다. 단어는 Sanity Free Coding 의 블로그 소유자에게만 속합니다 .

오늘 나는 내 응용 프로그램이 여러 인스턴스를 실행하지 못하게하는 코드를 리팩토링하고 싶었습니다.

이전에는 System.Diagnostics.Process 를 사용 하여 프로세스 목록에서 myapp.exe의 인스턴스를 검색했습니다. 이것이 작동하는 동안 많은 오버 헤드가 발생하고 더 깨끗한 것을 원했습니다.

나는 이것을 위해 뮤텍스를 사용할 수 있다는 것을 알았지 만 (이전에 한 번도 해본 적이 없다) 나는 코드를 줄이고 내 인생을 단순화하기 시작했다.

내 응용 프로그램 main 클래스에서 Mutex 라는 정적을 만들었습니다 .

static class Program
{
    static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
    [STAThread]
    ...
}

명명 된 뮤텍스를 사용하면 여러 스레드와 프로세스에서 동기화를 스택 할 수 있습니다. 이것은 내가 찾고있는 마술 일뿐입니다.

Mutex.WaitOne 에는 대기 시간을 지정하는 과부하가 있습니다. 실제로 코드를 동기화하고 싶지 않기 때문에 (현재 사용 중인지 확인하십시오) Mutex.WaitOne (Timespan timeout, bool exitContext) 매개 변수와 함께 오버로드를 사용합니다 . 기다릴 수 있으면 true를 입력하고 입력 할 수 없으면 false를 리턴합니다. 이 경우, 우리는 전혀 기다리기를 원하지 않습니다. 우리의 뮤텍스가 사용 중이라면 그것을 건너 뛰고 계속 진행하여 TimeSpan.Zero (0 밀리 초 대기)를 전달하고 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를 사용하여 실행중인 인스턴스에 이미 실행 중임을 잊었다는 것을 알리는 것을 선택했습니다 (다른 모든 창의 맨 위로 가져옴). 이것을 달성하기 위해 PostMessage 를 사용 하여 모든 창에 사용자 정의 메시지를 브로드 캐스트했습니다 (사용자 정의 메시지는
실행중인 응용 프로그램에 의해 RegisterWindowMessage 에 등록 되었습니다. 즉, 내 응용 프로그램만이 무엇인지 알 수 있습니다). 두 번째 인스턴스가 종료됩니다. 실행중인 응용 프로그램 인스턴스는 해당 알림을 수신하여 처리합니다. 이를 위해 WndProc 을 기본 형식으로 대체 하고 사용자 지정 알림을 수신했습니다. 해당 알림을 받았을 때 폼의 TopMost 속성을 true로 설정하여 맨 위에 표시했습니다.

내가 끝내는 것은 다음과 같습니다.

• Program.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;
    }
}

답변

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

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

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

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

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
}