¿Cuál es la forma correcta de crear una aplicación WPF de instancia única?
https://stackoverflow.com/questions/19147
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Usando C# y WPF bajo .NET (en lugar de Formularios de Windows o consola), ¿cuál es la forma correcta de crear una aplicación que solo se puede ejecutar como una instancia única?
Sé que tiene algo que ver con algo mítico llamado mutex, rara vez puedo encontrar a alguien que se moleste en detenerse y explicar cuáles son uno de estos.
El código también debe informar a la instancia que ya se está ejecutando que el usuario intentó iniciar una segunda y tal vez también pasar cualquier argumento de línea de comando, si existiera alguno.
Solución
Aquí hay una muy buena artículo con respecto a la solución Mutex.El enfoque descrito en el artículo es ventajoso por dos razones.
En primer lugar, no requiere dependencia del ensamblado Microsoft.VisualBasic.Si mi proyecto ya dependiera de esa asamblea, probablemente recomendaría usar el enfoque se muestra en otra respuesta.Pero tal como están las cosas, no uso el ensamblado Microsoft.VisualBasic y prefiero no agregar una dependencia innecesaria a mi proyecto.
En segundo lugar, el artículo muestra cómo poner en primer plano la instancia existente de la aplicación cuando el usuario intenta iniciar otra instancia.Ese es un detalle muy agradable que las otras soluciones de Mutex descritas aquí no abordan.
ACTUALIZAR
A partir del 1/8/2014, el artículo que vinculé anteriormente todavía está activo, pero el blog no se ha actualizado por un tiempo.Eso me preocupa que eventualmente pueda desaparecer, y con él, la solución defendida.Reproduzco aquí el contenido del artículo para la posteridad.Las palabras pertenecen únicamente al propietario del blog en Codificación libre de cordura.
Hoy quería refactorizar algún código que prohíba mi aplicación ejecutar múltiples instancias de sí misma.
Anteriormente había usado Proceso.de.diagnóstico.del.sistema Para buscar una instancia de mi myapp.exe en la lista de procesos.Mientras esto funciona, trae muchas por encima, y quería algo más limpio.
Sabiendo que podría usar un mutex para esto (pero nunca haberlo hecho antes) me propuse cortar mi código y simplificar mi vida.
En la clase principal de mi aplicación creé una estática llamada exclusión mutua:
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
...
}
Tener un mutex con nombre nos permite apilar la sincronización en múltiples hilos y procesos, que es solo la magia que estoy buscando.
Mutex.Espera uno tiene una sobrecarga que especifica una cantidad de tiempo para que esperemos.Dado que en realidad no queremos sincronizar nuestro código (más simplemente verifique si está actualmente en uso) usamos la sobrecarga con dos parámetros: Mutex.WaitOne (tiempo de espera de intervalo, contexto de salida bool).Espere, uno devuelve verdadero si puede ingresar y falso si no pudo ingresar.En este caso, no queremos esperar nada;Si nuestro mutex se está utilizando, omitirlo y seguir adelante, para que pasemos en Timespan.Zero (espere 0 milisegundos) y establezca el ExitContext en verdadero para que podamos salir del contexto de sincronización antes de intentar acumular un bloqueo en él.Usando esto, envolvemos nuestro código de aplicación.
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");
}
}
}
Entonces, si nuestra aplicación se está ejecutando, WaitOne devolverá falso y obtendremos un cuadro de mensaje.
En lugar de mostrar un cuadro de mensaje, opté por utilizar un pequeño Win32 para notificar a mi instancia de ejecución que alguien olvidó que ya estaba ejecutando (al llevar a la parte superior de todas las demás ventanas).Para lograr esto, utilicé Publicar mensaje Para transmitir un mensaje personalizado a cada ventana (el mensaje personalizado se registró con RegistrarseVentanaMensajePor mi aplicación en ejecución, lo que significa que solo mi aplicación sabe lo que es), luego mi segunda instancia sale.La instancia de la aplicación en ejecución recibiría esa notificación y la procesaría.Para hacer eso, anulé WndProc en mi forma principal y escuché mi notificación personalizada.Cuando recibí esa notificación, establecí la propiedad más alta del formulario en verdad para mencionarla.
Esto es con lo que terminé:
- 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);
}
}
}
- Métodos nativos.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 (anverso 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;
}
}
Otros consejos
Podrías usar la clase Mutex, pero pronto descubrirás que necesitarás implementar el código para pasar los argumentos y demás tú mismo.Bueno, aprendí un truco al programar en WinForms cuando leí El libro de Chris Sell..Este truco utiliza lógica que ya está disponible en el marco.No sé ustedes, pero cuando aprendo cosas que puedo reutilizar en el marco, ese suele ser el camino que tomo en lugar de reinventar la rueda.A menos, por supuesto, que no haga todo lo que quiero.
Cuando entré en WPF, se me ocurrió una manera de usar el mismo código, pero en una aplicación WPF.Esta solución debería satisfacer sus necesidades según su pregunta.
Primero, necesitamos crear nuestra clase de aplicación.En esta clase anularemos el evento OnStartup y crearemos un método llamado Activar, que se usará más adelante.
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();
}
}
En segundo lugar, necesitaremos crear una clase que pueda administrar nuestras instancias.Antes de continuar con eso, vamos a reutilizar parte del código que se encuentra en el ensamblado Microsoft.VisualBasic.Como estoy usando C# en este ejemplo, tuve que hacer una referencia al ensamblado.Si está utilizando VB.NET, no tiene que hacer nada.La clase que usaremos es WindowsFormsApplicationBase y heredaremos nuestro administrador de instancias y luego aprovecharemos las propiedades y eventos para manejar la instancia ú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();
}
}
Básicamente, estamos usando los bits VB para detectar instancias únicas y procesarlas en consecuencia.OnStartup se activará cuando se cargue la primera instancia.OnStartupNextInstance se activa cuando la aplicación se vuelve a ejecutar.Como puede ver, puedo acceder a lo que se pasó en la línea de comando a través de los argumentos del evento.Establecí el valor en un campo de instancia.Puede analizar la línea de comando aquí o puede pasarla a su aplicación a través del constructor y la llamada al método Activate.
En tercer lugar, es hora de crear nuestro EntryPoint.En lugar de actualizar la aplicación como lo haría normalmente, aprovecharemos nuestro SingleInstanceManager.
public class EntryPoint
{
[STAThread]
public static void Main(string[] args)
{
SingleInstanceManager manager = new SingleInstanceManager();
manager.Run(args);
}
}
Bueno, espero que puedas seguir todo y puedas utilizar esta implementación y hacerla tuya.
De aquí.
Un uso común de un Mutex entre procesos es garantizar que solo se pueda ejecutar una instancia de un programa a la vez.Así es como se hace:
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();
}
}
}
Una buena característica de Mutex es que si la aplicación finaliza sin que se llame primero a ReleaseMutex, CLR liberará el Mutex automáticamente.
MSDN en realidad tiene una aplicación de muestra para C# y VB para hacer exactamente esto: http://msdn.microsoft.com/en-us/library/ms771662(v=VS.90).aspx
La técnica más común y confiable para desarrollar la detección de una sola instancia es utilizar la infraestructura remotora de Microsoft .NET Framework (System.Remoting).El Microsoft .NET Framework (versión 2.0) incluye un tipo, WindowsFormsApplicationBase, que encapsula la funcionalidad de referencia requerida.Para incorporar este tipo en una aplicación WPF, un tipo debe derivar de ella y usarse como una cuña entre el método de punto de entrada estático de la aplicación, Main y el tipo de aplicación de la aplicación WPF.La cuña detecta cuándo se inicia una aplicación por primera vez, y cuándo se intentan los lanzamientos posteriores, y produce control del tipo de aplicación WPF para determinar cómo procesar los lanzamientos.
- Para la gente de C#, simplemente respire hondo y olvídese de todo el asunto "No quiero incluir VisualBasic DLL".Porque este y qué Scott Hanselman dice y el hecho de que esta es prácticamente la solución más limpia al problema y está diseñada por personas que saben mucho más sobre el marco que usted.
- Desde el punto de vista de la usabilidad, el hecho es que si su usuario está cargando una aplicación y ya está abierta y le está dando un mensaje de error como
'Another instance of the app is running. Bye'entonces no será un usuario muy feliz.Simplemente DEBE (en una aplicación GUI) cambiar a esa aplicación y pasar los argumentos proporcionados, o si los parámetros de la línea de comando no tienen significado, entonces debe abrir la aplicación que puede haber sido minimizada.
El marco ya admite esto; es solo que un idiota nombró la DLL Microsoft.VisualBasic y no fue puesto en Microsoft.ApplicationUtils o algo así.Supéralo o abre Reflector.
Consejo:Si utiliza este enfoque exactamente como está y ya tiene un App.xaml con recursos, etc.querrás hacerlo mira esto también.
Este código debe ir al método principal.Mira a aquí para obtener más información sobre el método principal en 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 : Los métodos anteriores suponen que su proceso/aplicación tiene un nombre único.Porque utiliza el nombre del proceso para encontrar procesadores existentes.Entonces, si su aplicación tiene un nombre muy común (es decir:Bloc de notas), el método anterior no funcionará.
Bueno, tengo una clase desechable para esto que funciona fácilmente en la mayoría de los casos de uso:
Úselo así:
static void Main()
{
using (SingleInstanceMutex sim = new SingleInstanceMutex())
{
if (sim.IsOtherInstanceRunning)
{
Application.Exit();
}
// Initialize program here.
}
}
Aquí lo tienes:
/// <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
}
Uno nuevo que usa elementos Mutex e IPC, y también pasa cualquier argumento de línea de comando a la instancia en ejecución, es Aplicación de instancia única WPF.
El código Aplicación de instancia única C# .NET esa es la referencia para la respuesta marcada es un gran comienzo.
Sin embargo, descubrí que no maneja muy bien los casos en los que la instancia que ya existe tiene un cuadro de diálogo modal abierto, ya sea que ese cuadro de diálogo sea administrado (como otro formulario, como un cuadro Acerca de), o uno no administrado (como el OpenFileDialog incluso cuando se utiliza la clase .NET estándar).Con el código original, el formulario principal está activado, pero el modal permanece inactivo, lo que parece extraño, además el usuario debe hacer clic en él para seguir usando la aplicación.
Entonces, creé una clase de utilidad SingleInstance para manejar todo esto de manera bastante automática para aplicaciones Winforms y WPF.
Winforms:
1) modificar la clase Programa así:
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) modifique la clase de la ventana principal así:
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) modifique la página de la aplicación de esta manera (y asegúrese de configurar su acción de compilación en página para poder redefinir el método principal):
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) modifique la clase de la ventana principal así:
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;
}
Y aquí está la clase de utilidad:
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);
}
}
}
A continuación se muestra un ejemplo que le permite tener una única instancia de una aplicación.Cuando se cargan instancias nuevas, pasan sus argumentos a la instancia principal que se está ejecutando.
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);
}
Sólo algunas reflexiones:Hay casos en los que exigir que sólo una instancia de una aplicación no sea "poco convincente" como algunos quieren hacer creer.Aplicaciones de bases de datos, etc.son un orden de magnitud más difíciles si se permiten múltiples instancias de la aplicación para que un solo usuario acceda a una base de datos (ya sabes, toda esa actualización de todos los registros que están abiertos en múltiples instancias de la aplicación en la máquina del usuario, etc.) .Primero, para la "colisión de nombres", no use un nombre legible por humanos; use un GUID en su lugar o, mejor aún, un GUID + el nombre legible por humanos.Las posibilidades de colisión de nombres simplemente desaparecieron del radar y a Mutex no le importa.Como alguien señaló, un ataque de DOS sería una mierda, pero si la persona malintencionada se ha tomado la molestia de obtener el nombre mutex e incorporarlo a su aplicación, usted es prácticamente un objetivo de todos modos y tendrá que hacer MUCHO más para protegerse. que simplemente manipular un nombre mutex.Además, si se utiliza la variante de:nuevo Mutex (verdadero, "algún GUID más nombre", fuera AIsFirstInstance), ya tiene su indicador sobre si Mutex es o no la primera instancia.
Tantas respuestas a una pregunta aparentemente tan sencilla.Sólo para cambiar un poco las cosas, aquí está mi solución a este problema.
Crear un Mutex puede ser problemático porque JIT-er solo ve que lo usas para una pequeña porción de tu código y quiere marcarlo como listo para la recolección de basura.Básicamente quiere ser más inteligente que tú pensando que no vas a usar ese Mutex por tanto tiempo.En realidad, desea conservar este Mutex mientras su aplicación esté ejecutándose.La mejor manera de decirle al recolector de basura que lo deje en paz con Mutex es decirle que lo mantenga vivo a lo largo de las diferentes generaciones de recolección de garaje.Ejemplo:
var m = new Mutex(...);
...
GC.KeepAlive(m);
Saqué la idea de esta página: http://www.ai.uga.edu/~mc/SingleInstance.html
Parece que hay una muy buena manera de manejar esto:
Aplicación de instancia única WPF
Esto proporciona una clase que puede agregar y que administra todos los mutex y mensajes innecesarios para simplificar su implementación hasta el punto en que sea simplemente trivial.
El siguiente código es mi solución de canalizaciones con nombre WCF para registrar una aplicación de instancia única.Es bueno porque también genera un evento cuando otra instancia intenta iniciarse y recibe la línea de comando de la otra instancia.
Está orientado a WPF porque utiliza el System.Windows.StartupEventHandler clase, pero esto podría modificarse fácilmente.
Este código requiere una referencia a PresentationFramework, y 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 fuente:
/// <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);
}
}
}
}
Nunca debes usar un mutex con nombre para implementar una aplicación de instancia única (o al menos no para código de producción).El código malicioso puede fácilmente DoS (Negación de servicio) tu culo...
Esto es lo que uso.Combinó la enumeración de procesos para realizar conmutación y mutex para protegerse de "clickers activos":
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();
}
}
Encontré la solución más simple, similar a la de Dale Ragan, pero ligeramente modificada.Hace prácticamente todo lo que necesita y se basa en la clase estándar Microsoft WindowsFormsApplicationBase.
En primer lugar, crea la clase SingleInstanceController, que puede usar en todas las demás aplicaciones de instancia única que usan 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);
}
}
}
Luego puedes usarlo en tu programa de la siguiente manera:
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 el programa como la solución SingleInstanceController_NET deben hacer referencia a Microsoft.VisualBasic.Si solo desea reactivar la aplicación en ejecución como una ventana normal cuando el usuario intenta reiniciar el programa en ejecución, el segundo parámetro en SingleInstanceController puede ser nulo.En el ejemplo dado, la ventana está maximizada.
Mire el siguiente código.Es una solución excelente y sencilla para evitar múltiples instancias de una aplicación 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();
}
}
Sin embargo, no uso Mutex, respuesta simple:
System.Diagnostics;
...
string thisprocessname = Process.GetCurrentProcess().ProcessName;
if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
return;
Ponlo dentro del Program.Main().
Ejemplo:
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());
}
}
}
Puedes añadir MessageBox.Show hacia if-instrucción y ponga "La aplicación ya se está ejecutando".
Esto podría ser útil para alguien.
Actualización 2017-01-25. Después de probar algunas cosas, decidí usar VisualBasic.dll, es más fácil y funciona mejor (al menos para mí).Dejé mi respuesta anterior solo como referencia...
Solo como referencia, así es como lo hice sin pasar argumentos (que no encuentro ninguna razón para hacerlo...Me refiero a una única aplicación con argumentos que se pasan de una instancia a otra).Si se requiere una asociación de archivos, entonces se debe instanciar una aplicación (según las expectativas estándar de los usuarios) para cada documento.Si tiene que pasar argumentos a una aplicación existente, creo que usaría vb dll.
Al no pasar argumentos (solo una aplicación de instancia única), prefiero no registrar un nuevo mensaje de Windows y no anular el bucle de mensajes como se define en la solución Matt Davis.Aunque no es gran cosa agregar una DLL de VisualBasic, prefiero no agregar una nueva referencia solo para hacer una aplicación de instancia única.Además, prefiero instanciar una nueva clase con Main en lugar de llamar a Shutdown desde App.Startup override para asegurarme de salir lo antes posible.
Espero que a alguien le guste...o te inspirará un poco :-)
La clase de inicio del proyecto debe configurarse 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);
}
}
}
}
}
}
}
Ayudante de ventana:
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);
Utilice una solución mutex:
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;
}
}
}
}
}
Aquí hay una solución liviana que uso que permite a la aplicación traer una ventana ya existente al primer plano sin recurrir a mensajes personalizados de Windows o buscar ciegamente nombres de procesos.
[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:También puede almacenar e inicializar mutex y createNew estáticamente, pero deberá eliminar/liberar explícitamente el mutex una vez que haya terminado.Personalmente, prefiero mantener el mutex local ya que se eliminará automáticamente incluso si la aplicación se cierra sin llegar al final de Main.
También puedes utilizar el Tiempo de ejecución fluido de código que es un conjunto gratuito de herramientas.Proporciona un Única instancia clase para implementar una aplicación de instancia única.
Aquí está lo mismo implementado a través de Evento.
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();
}
}
Los enfoques basados en mutex con nombre no son multiplataforma porque los mutex con nombre no son globales en Mono.Los enfoques basados en enumeración de procesos no tienen ninguna sincronización y pueden dar lugar a un comportamiento incorrecto (p. ej.varios procesos iniciados al mismo tiempo pueden autoterminar dependiendo del tiempo).Los enfoques basados en sistemas de ventanas no son deseables en una aplicación de consola.Esta solución, construida sobre la respuesta de Divin, aborda todas estas cuestiones:
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.");
}
}
}
}
no puedo encontrar un solución corta aquí así que espero que a alguien le guste esto:
ACTUALIZADO 2018-09-20
(Por cierto.pon el código en tu "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.Si no quieres que alguien lo ejecute, tienes un ".exe" con otro nombre:
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());
}
Agregué un método sendMessage a la clase NativeMethods.
Aparentemente, el método postmessage no funciona si la aplicación no se muestra en la barra de tareas; sin embargo, usar el método sendmessage resuelve este problema.
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);
}
Por lo general, cada vez que ejecutamos un .exe, cada vez crea un proceso de Windows separado con su propio espacio de direcciones, recursos, etc.Pero no queremos este criterio porque nos impediría crear un proceso único.Se pueden crear aplicaciones de instancia única utilizando Mutex en C#, que se discute en este artículo
Además, si queremos llevar la aplicación a la cima, podemos hacerlo usando
[DllImport("user32")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);
Normalmente, este es el código que uso para instancia única. Formularios de Windows aplicaciones:
[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());
}
}
}
Donde los componentes nativos son:
[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
}
Aquí hay una solución:
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
Así es como terminé ocupándome de este problema.Tenga en cuenta que el código de depuración todavía está ahí para realizar pruebas.Este código se encuentra dentro de OnStartup en el archivo App.xaml.cs.(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();
}
Es posible que esto tenga problemas que aún no he detectado.Si me encuentro con alguno, actualizaré mi respuesta.
