Qual é a maneira correta para criar uma única instância de aplicativo do WPF?
https://stackoverflow.com/questions/19147
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Usando o C# e o WPF abrigo .LÍQUIDA (em vez de Windows Forms ou console), que é a maneira correta de criar um aplicativo que pode ser executado apenas uma única instância?
Eu sei que tem algo a ver com algumas mítico chamado de um mutex, raramente posso encontrar alguém que te incomoda para parar e explicar o que estes são.
O código precisa também informar a instância já em execução que o usuário tentou iniciar uma segunda, e talvez também passar os argumentos de linha de comando se qualquer existia.
Solução
Aqui é muito bom artigo sobre o Mutex solução.A abordagem descrita pelo artigo é vantajosa por dois motivos.
Primeiro, ele não requer uma dependência no Microsoft.VisualBasic assembleia.Se o meu projeto já tinha uma dependência na assembléia, eu provavelmente iria defender usando a abordagem mostrado em outra resposta.Mas como é, eu não uso a Microsoft.VisualBasic assembléia, e eu prefiro não adicionar uma desnecessária dependência para o meu projeto.
Segundo, o artigo mostra como colocar a instância existente do aplicativo para o primeiro plano quando o usuário tenta iniciar outra instância.Que da um toque muito agradável que as outras Mutex soluções aqui descritas não endereço.
ATUALIZAÇÃO
Como de 8/1/2014, o artigo I ligada à anterior ainda está ativa, mas o blog não foi atualizado por um tempo.Que me faz pensar que, eventualmente, pode desaparecer, e com ele, a solução defendida.Estou reproduzindo o conteúdo do artigo, aqui, para a posteridade.As palavras pertencem exclusivamente ao proprietário do blog em Sanidade Código Livre.
Hoje eu queria refatorar um código que proíbe a minha candidatura a execução de várias instâncias de si mesmo.
Anteriormente, eu tinha de usar Do sistema.O diagnóstico.Processo para procurar um instância de meu myapp.exe na lista de processos.Enquanto isso funciona, é traz um monte de sobrecarga, e eu queria algo mais limpo.
Sabendo que eu poderia usar um mutex para isso (mas nunca o ter feito isso antes de eu cortar o meu código e simplificar minha vida.
Na classe da minha aplicação principal criei um estático chamado Mutex:
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
...
}
Ter um mutex nomeado nos permite pilha de sincronização através de vários threads e processos, que é apenas a magia que eu estou procurando para.
Mutex.WaitOne tem uma sobrecarga que especifica um período de tempo para nós esperar.Desde que nós não estamos realmente querendo a sincronização de nossa código (mais basta verificar se ele está em uso) usamos a sobrecarga com dois parâmetros: Mutex.WaitOne(intervalo de tempo de tempo de espera, bool exitContext).Aguarde um retorna true se ele é capaz de entrar, e false se não.Neste caso, nós não quer esperar;Se o nosso mutex está sendo usado, ignorá-lo, e passar, então, podemos passar TimeSpan.Zero (aguarde 0 milissegundos), e definir o exitContext para true para que possamos sair do sincronização de contexto antes de tentar adquirir um bloqueio sobre ele.Usando isso, envolvemos a nossa Aplicação.Executar o código dentro de algo parecido com isto:
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");
}
}
}
Assim, se o aplicativo está sendo executado, WaitOne irá retornar false, e nós vamos ter uma caixa de mensagem.
Em vez de mostrar uma caixa de mensagem, optei por utilizar um pouco de Win32 notificar minha instância em execução que alguém se esqueceu que já foi execução (trazendo em si para o topo de todas as outras janelas).Para alcançar esse eu usei PostMessage a transmissão de uma mensagem personalizada para cada a janela de mensagem personalizada foi registrado com RegisterWindowMessage pelo meu aplicativo em execução, o que significa que apenas a minha candidatura sabe o que ele é), então a minha segunda instância sai.A execução instância do aplicativo gostaria de receber a notificação, e processá-lo.Para fazer isso, eu cancelamos WndProc no meu formulário principal e ouvia minha personalizado a notificação.Quando recebi a notificação de que eu defini o formulário Superior propriedade para true para trazê-lo em cima.
Aqui está o que eu acabei com:
- O programa.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 (lado frontal parcial)
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;
}
}
Outras dicas
Você pode usar a classe Mutex, mas em breve você vai descobrir que você vai precisar para implementar o código para passar os argumentos e tal a si mesmo.Bem, eu aprendi um truque quando a programação em WinForms quando eu ler Chris Vender o livro.Este truque usa a lógica que já está disponível para nós no quadro.Eu não sei sobre você, mas quando eu aprender sobre coisas que eu pode reutilizar a estrutura, que geralmente é o caminho que eu tomar, em vez de reinventar a roda.A menos, claro, ele não faz tudo que eu quero.
Quando eu cheguei em WPF, eu vim acima com uma maneira de usar o mesmo código, mas em um aplicativo do WPF.Esta solução deve atender às suas necessidades fora de sua pergunta.
Primeiro, precisamos criar a nossa classe de aplicação.Nesta aula vamos substituir o OnStartup de evento e criar um método chamado de Ativar, o que vai ser usado mais tarde.
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();
}
}
Segundo, nós precisamos criar uma classe que pode gerir as nossas instâncias.Antes de passar por isso, nós estamos indo realmente para a reutilização de código que está na Microsoft.VisualBasic assembleia.Desde então, eu estou usando C# neste exemplo, eu tive que fazer uma referência para o assembly.Se você estiver usando o VB.NET, você não tem que fazer nada.A classe vai usar é WindowsFormsApplicationBase e herdar o nosso gestor de instância fora dele e, em seguida, aproveitar as propriedades e eventos para lidar com a criação de instância única.
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();
}
}
Basicamente, nós estamos usando o VB bits para detectar única instância e o processo de acordo.OnStartup será acionado quando a primeira instância de cargas.OnStartupNextInstance é disparado quando a aplicação é re-executado novamente.Como você pode ver, eu posso obter o que foi passado na linha de comando, através de argumentos do evento.Eu defina o valor para um campo de instância.Você poderia analisar a linha de comando aqui, ou você poderá passar para a sua candidatura através do construtor e a chamada para o método Activate.
Terceiro, é hora de criar o nosso ponto de entrada.Em vez de newing o aplicativo como você faria normalmente, vamos aproveitar o nosso SingleInstanceManager.
public class EntryPoint
{
[STAThread]
public static void Main(string[] args)
{
SingleInstanceManager manager = new SingleInstanceManager();
manager.Run(args);
}
}
Bem, eu espero que você é capaz de seguir tudo e ser capaz de usar esta implementação e torná-lo seu próprio.
A partir de aqui.
Um uso comum para um cross-processo de exclusão mútua é para garantir que o único exemplo de um programa pode ser executado ao mesmo tempo.Veja como é feito:
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();
}
}
}
Um bom recurso de exclusão mútua é que se encerra o aplicativo sem ReleaseMutex primeiro a ser chamado, o CLR vai liberar o Mutex automaticamente.
MSDN, na verdade, tem uma aplicação de exemplo para C# e VB para fazer exatamente isso: http://msdn.microsoft.com/en-us/library/ms771662(v=VS.90).aspx
O mais comum e confiável técnica para o desenvolvimento de instância única a detecção é usar o Microsoft .NET Framework remoting infra-estrutura (Sistema.Sistema de interacção remota).A Microsoft .NET Framework (versão 2.0) inclui uma tipo, WindowsFormsApplicationBase, que encapsula o necessário funcionalidade remota.Para incorporar este tipo em um aplicativo do WPF, um tipo de necessidades para derivar e ser usado como um calço entre a aplicação estático de ponto de entrada do método, Principais, e o WPF da aplicação escreva.A correção detecta quando um aplicativo é iniciado pela primeira vez, e quando lançamentos subsequentes são tentou, e produz controle do WPF Tipo de aplicação para determinar como processo lançamentos.
- Para C# pessoas apenas respire fundo e esqueça-se sobre todo o 'eu não quero incluir o VisualBasic DLL'.Porque de este e o que Scott Hanselman diz e o fato de que esta muito bonita é a mais limpa de solução para o problema e é concebido por pessoas que sabem muito mais sobre o framework que você.
- A partir de um ponto de vista de usabilidade o fato é que se o utilizador está a carregar um aplicativo e ele já está aberto e você está dando a eles uma mensagem de erro como
'Another instance of the app is running. Bye'em seguida, eles não hão de ser um usuário muito feliz.Você simplesmente TEM (em um aplicativo GUI) alterne para o aplicativo e passe a argumentos - ou se parâmetros de linha de comando não tem nenhum significado, em seguida, você deve abrir o aplicativo, que pode ter sido minimizado.
O quadro já tem suporte a isso - apenas que algum idiota chamado de DLL Microsoft.VisualBasic e não se colocar em Microsoft.ApplicationUtils ou algo parecido.Get over it - ou abrir o Refletor.
Dica:Se você usar essa abordagem exatamente como é, e você já tem um App.xaml com recursos etc.você vai querer dê uma olhada nesta muito.
Este código deve ir para o método main.Olhar aqui para obter mais informações sobre o método main no WPF.
[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;
}
}
Método 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(...);
}
}
Nota : Métodos acima assume que o seu processo/aplicação tem um nome exclusivo.Porque ele usa o nome do processo para se encontrar qualquer existente processadores.Assim, se o seu aplicativo tem um nome muito comum (ou seja:O bloco de notas), acima de abordagem não funciona.
Bem, eu tenho uma descartável, Classe esta que trabalha fácil para a maioria dos casos de uso:
Usá-lo assim:
static void Main()
{
using (SingleInstanceMutex sim = new SingleInstanceMutex())
{
if (sim.IsOtherInstanceRunning)
{
Application.Exit();
}
// Initialize program here.
}
}
Aqui está ele:
/// <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
}
Um novo que utiliza Mutex e IPC coisas, e também passa quaisquer argumentos de linha de comando para a instância em execução, é WPF Aplicação de Instância Única.
O código C# .NET Aplicação de Instância Única que é a referência para o marcado de resposta é um grande começo.
No entanto, eu encontrei ele não lidar muito bem os casos quando a instância que já existe tem uma caixa de diálogo modal aberto, se essa caixa de diálogo é uma gestão (como uma outra Forma, como uma janela sobre), ou um não-gerenciado (como o OpenFileDialog, mesmo quando usando o padrão .NET classe).Com o código original, o formulário principal é ativado, mas o modal permanece unactive, o que parece estranho, mais o usuário deve clicar sobre ele para continuar usando o aplicativo.
Então, eu tenho de criar uma ocorrência única classe de utilitário para lidar com todas essas coisas automaticamente para Winforms e aplicações WPF.
Winforms:
1) modificar o Programa, de classe, como este:
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) modificar o principal classe de janela como esta:
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) modificar a página do Aplicativo como este (e certifique-se de que você defina sua acção criar a página para ser capaz de redefinir o método 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) modificar o principal classe de janela como esta:
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;
}
E aqui é a classe de utilitário:
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);
}
}
}
Aqui está um exemplo que permite que você tenha uma única instância de um aplicativo.Quando novas instâncias de carga, eles passam seus argumentos para a principal instância que está sendo executado.
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);
}
Apenas alguns pensamentos:Há casos em que a exigência de que apenas uma instância de uma aplicação não é "manco", como alguns querem fazer crer.Aplicativos de banco de dados, etc.é uma ordem de magnitude mais difícil se se permite que várias instâncias do aplicativo para um único usuário para acessar um banco de dados (você sabe, tudo o que a actualização de todos os registos que estão abertas em várias instâncias do aplicativo na máquina dos usuários, etc.).Primeiro, para o "nome de colisão coisa, não use um formato legível por humanos nome - use um GUID em vez, ou ainda melhor um GUID + o legível do nome.As Chances de colisão de nome acaba de cair fora do radar e o Mutex não se importa.Como alguém apontou, um ataque DOS iria chupar, mas se a pessoa mal intencionada tenha ido para a dificuldade de obter o nome do mutex e incorporar em seu aplicativo, você é muito bonito um destino de qualquer maneira e terá que fazer MUITO mais para proteger a si mesmo do que apenas mexer um nome de mutex.Também, se se utiliza a variante de:novo Mutex(true, "alguns GUID Nome a mais", fora AIsFirstInstance), você já tem o seu indicador para saber se ou não o Mutex é a primeira instância.
Muitas respostas a tais aparentemente simples pergunta.Só para agitar as coisas um pouco, aqui está a minha solução para este problema.
A criação de um Mutex pode ser problemático porque o JIT-er só vê você usando-o para uma pequena parte do seu código e quer marcá-la como pronta para coleta de lixo.Muito bonito, quer fora esperto você pensar que você não vai usar Mutex por muito tempo.Na realidade, você deseja manter este Mutex por enquanto o aplicativo estiver em execução.A melhor maneira de dizer o coletor de lixo para deixar você Mutex sozinho é dizer a ele para mantê-lo vivo, embora as diferentes gerações de garagem coleção.Exemplo:
var m = new Mutex(...);
...
GC.KeepAlive(m);
Eu levantei a ideia de esta página: http://www.ai.uga.edu/~mc/SingleInstance.html
Parece que há é uma boa maneira para lidar com isso:
WPF Aplicação de Instância Única
Isso fornece uma classe, você pode adicionar que gerencia todo o mutex e mensagens cruff para simplificar a sua implementação para o ponto onde ele está simplesmente trivial.
O código a seguir é a minha WCF pipes nomeados solução para registrar uma ocorrência única aplicação.É bom porque ele também gera um evento quando outra instância tentativas para iniciar, e recebe a linha de comando de outra instância.
Ele está voltado para WPF, porque ele usa a System.Windows.StartupEventHandler classe, mas isso pode ser facilmente modificado.
Este código requer uma referência para PresentationFramework, e System.ServiceModel.
Uso:
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.
}
}
Código-Fonte:
/// <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);
}
}
}
}
Você nunca deve usar um mutex nomeado para implementar uma aplicação de instância única (ou, pelo menos, não para o código de produção).Código mal-intencionado pode facilmente DoS (Negação de Serviço) o cu...
Aqui está o que eu uso.Combinou-se o processo de enumeração para fazer a manobra e de exclusão mútua para se proteger da "active clickers":
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();
}
}
Eu encontrei a solução mais simples, semelhante ao Dale Ragan, mas ligeiramente modificado.Ele faz praticamente tudo o que você precisa e com base no padrão do Microsoft WindowsFormsApplicationBase classe.
Em primeiro lugar, criar SingleInstanceController de classe, que você pode usar em todos os outros de instância única de aplicações, que utilizam Windows Forms:
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);
}
}
}
Em seguida, você pode usá-lo em seu programa como se segue:
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();
}
}
}
Tanto o programa e o SingleInstanceController_NET solução deve fazer referência a Microsoft.VisualBasic .Se você só quer reativar a execução da aplicação como uma janela normal quando o usuário tenta reiniciar o programa em execução, o segundo parâmetro na SingleInstanceController pode ser nulo.No exemplo dado, a janela é maximizada.
Olhe para o seguinte código.É uma simples solução para evitar que várias instâncias de um aplicativo do 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();
}
}
Não usar Mutex, porém, uma resposta simples:
System.Diagnostics;
...
string thisprocessname = Process.GetCurrentProcess().ProcessName;
if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
return;
Coloque-a dentro da Program.Main().
Exemplo:
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());
}
}
}
Você pode adicionar MessageBox.Show para o if-instrução e colocar "Aplicativo já está em execução".
Isso pode ser útil para alguém.
Atualização 2017-01-25. Depois de tentar algumas coisas, eu decidi ir com VisualBasic.dll é mais fácil e funciona melhor (pelo menos para mim).Eu deixei minha resposta anterior apenas como referência...
Apenas como referência, esta é a forma como eu fiz sem passar argumentos (o que eu não posso encontrar qualquer razão para fazer isso...Eu quero dizer uma única aplicação com argumentos de que para ser passados a partir de uma instância para outra).Se de associação de arquivo é necessário, então de uma aplicação (por usuários padrão expectativa) ser instanciated para cada documento.Se você tem que passar argumentos para aplicação já existente, eu acho que teria usado a dll do vb.
Não passar args (apenas uma instância de aplicativo), eu prefiro não registar uma nova Janela de mensagem e não substituir o loop de mensagem, como definido na Matt Davis Solução.Apesar de não ser um grande negócio para adicionar um VisualBasic dll, mas eu prefiro adicionar uma nova referência apenas para fazer instância única aplicação.Também, eu prefiro instanciate uma nova classe com Main, em vez de chamar o Encerramento do Aplicativo.Inicialização de substituição para garantir a sair mais rapidamente possível.
Na esperança de que alguém irá gostar de...ou vai inspirar um pouco :-)
Projeto de inicialização de classe deve ser definido como '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);
}
}
}
}
}
}
}
WindowHelper:
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);
Usar mutex solução:
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;
}
}
}
}
}
Aqui está uma leve solução que eu uso, o que permite o aplicativo para trazer um já existente janela para o primeiro plano sem recorrer ao costume de mensagens do windows ou cegamente processo de busca de nomes.
[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;
}
Editar:Você também pode armazenar e inicializar o mutex e createdNew estaticamente, mas você precisará explicitamente descarte/liberar o mutex, uma vez que você é feito com ele.Pessoalmente, eu prefiro manter o mutex locais como ele será automaticamente eliminado do mesmo se o aplicativo fecha sem nunca chegar a final da Principal.
Você também pode usar o CodeFluent Tempo De Execução o que é conjunto de ferramentas gratuito.Ele fornece uma Single-instance classe para implementar uma única instância da aplicação.
Aqui está a mesma coisa implementado através de Eventos.
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();
}
}
Nome-mutex baseado em abordagens não são multi-plataforma chamado porque exclusões mútuas não são globais em Mono.O processo de enumeração baseada em abordagens não têm qualquer sincronização e pode resultar em um comportamento incorreto (por exemplo,vários processos iniciados ao mesmo tempo pode tudo terminará dependendo do tempo).De janelas baseado em sistema de abordagens não são desejáveis em um aplicativo de console.Esta solução, construída em cima do século divino resposta, aborda todas estas questões:
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.");
}
}
}
}
Eu não posso encontrar uma curto solução aqui, então eu espero que alguém vai gostar deste:
ATUALIZADO 2018-09-20
(Btw.coloque o código que você está "Do programa.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;
}
// Código opcional.Se você não quer que alguém corre de você ".exe" com um nome diferente:
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());
}
Eu adicionei um Método sendMessage para o NativeMethods Classe.
Aparentemente, o método postmessage dosent de trabalho, se a aplicação não for exibido na barra de tarefas, no entanto, utilizando o método sendmessage resolve isso.
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);
}
Normalmente, sempre que executamos um .exe, cada vez que cria um processo do windows com seu próprio espaço de endereço, recursos e assim por diante.Mas nós não queremos que este critério como esse iria nos prevenir de criação de um único processo.Instância única, os aplicativos podem ser criados usando-se o Mutex em C# que é discutido neste artigo
Além disso, se queremos levar o aplicativo na parte superior, podemos fazê-lo usando
[DllImport("user32")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);
Normalmente, este é o código que eu uso para a instância única Windows Forms aplicações:
[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());
}
}
}
Onde componentes nativos são:
[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
}
Aqui está a solução:
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
Isso é como eu acabei de tomar cuidado com esta questão.Observe que o código de depuração ainda está lá para o teste.Este código está dentro do OnStartup no Aplicativo.xaml.cs arquivo.(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();
}
Isso pode ter problemas que eu não peguei ainda.Se eu executar em qualquer vou atualizar a minha resposta.
