Qual è il modo corretto per creare un'applicazione WPF a istanza singola?
https://stackoverflow.com/questions/19147
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Utilizzando C# e WPF in .NET (anziché Moduli Windows o console), qual è il modo corretto per creare un'applicazione che può essere eseguita solo come una singola istanza?
So che ha qualcosa a che fare con qualcosa di mitico chiamato mutex, raramente riesco a trovare qualcuno che si prenda la briga di fermarsi e spiegare cosa sono.
Il codice deve anche informare l'istanza già in esecuzione che l'utente ha tentato di avviarne una seconda e magari anche passare eventuali argomenti della riga di comando, se esistenti.
Soluzione
Ecco un ottimo articolo per quanto riguarda la soluzione Mutex.L’approccio descritto nell’articolo è vantaggioso per due ragioni.
Innanzitutto non richiede una dipendenza dall'assembly Microsoft.VisualBasic.Se il mio progetto dipendesse già da quell'assembly, probabilmente sosterrei l'utilizzo di questo approccio mostrato in un'altra risposta.Ma così com'è, non utilizzo l'assembly Microsoft.VisualBasic e preferisco non aggiungere una dipendenza non necessaria al mio progetto.
In secondo luogo, l'articolo illustra come portare in primo piano l'istanza esistente dell'applicazione quando l'utente tenta di avviare un'altra istanza.Questo è un tocco molto carino che le altre soluzioni Mutex qui descritte non affrontano.
AGGIORNAMENTO
Dall'8/1/2014, l'articolo che ho linkato sopra è ancora attivo, ma il blog non viene aggiornato da un po'.Ciò mi fa temere che alla fine potrebbe scomparire e, con esso, la soluzione auspicata.Riproduco qui il contenuto dell'articolo per i posteri.Le parole appartengono esclusivamente al proprietario del blog su Codifica senza sanità mentale.
Oggi volevo refactoring di un codice che proibisse alla mia applicazione di eseguire più istanze di se stessa.
In precedenza avevo l'uso System.Diagnostics.Process Per cercare un'istanza del mio myapp.exe nell'elenco dei processi.Mentre funziona, porta molto sopra la testa e volevo qualcosa di più pulito.
Sapendo che avrei potuto usare un mutex per questo (ma non averlo mai fatto prima) ho deciso di ridurre il mio codice e semplificare la mia vita.
Nella classe main della mia applicazione ho creato una statica denominata Mutex:
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
...
}
Avere un Mutex denominato ci consente di impilare la sincronizzazione su più thread e processi che è solo la magia che sto cercando.
Mutex.WaitOne ha un sovraccarico che specifica un periodo di tempo per noi di aspettare.Dal momento che in realtà non vogliamo sincronizzare il nostro codice (più controlla se è attualmente in uso) utilizziamo il sovraccarico con due parametri: Mutex.WaitOne (timeout del periodo di tempo, bool exitContext).Wait one restituisce true se è in grado di entrare e false se non lo è stato.In questo caso non vogliamo aspettare affatto;Se il nostro mutex viene utilizzato, saltalo e andiamo avanti, quindi passiamo in Timespan.Zero (attendere 0 millisecondi) e impostare ExitContext su True in modo da poter uscire dal contesto di sincronizzazione prima di provare ad attirare un blocco su di esso.Usando questo, avvolgiamo la nostra applicazione.run codice all'interno di qualcosa del genere:
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");
}
}
}
Quindi, se la nostra app è in esecuzione, WaitOne restituirà false e avremo una casella di messaggio.
Invece di mostrare una finestra di messaggio, ho deciso di utilizzare un po 'di Win32 per avvisare la mia istanza di corsa che qualcuno ha dimenticato che era già in esecuzione (portandosi in cima a tutte le altre finestre).Per raggiungere questo obiettivo che ho usato PostMessaggio per trasmettere un messaggio personalizzato ad ogni finestra (il messaggio personalizzato è stato registrato con RegisterWindowMessageCon la mia applicazione in esecuzione, il che significa che solo la mia applicazione sa di cosa si tratta), quindi la mia seconda istanza esce.L'istanza dell'applicazione in esecuzione riceverebbe tale notifica ed elaborerebbe.Per farlo, ho superato WndProc Nella mia forma principale e ho ascoltato la mia notifica personalizzata.Quando ho ricevuto quella notifica, ho impostato la proprietà più alta del modulo su True per sollevarla in cima.
Ecco cosa ho ottenuto:
- Program.cs
static class Program
{
static Mutex mutex = new Mutex(true, "{8F6F0AC4-B9A1-45fd-A8CF-72F04E6BDE8F}");
[STAThread]
static void Main() {
if(mutex.WaitOne(TimeSpan.Zero, true)) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
mutex.ReleaseMutex();
} else {
// send our Win32 message to make the currently running instance
// jump on top of all the other windows
NativeMethods.PostMessage(
(IntPtr)NativeMethods.HWND_BROADCAST,
NativeMethods.WM_SHOWME,
IntPtr.Zero,
IntPtr.Zero);
}
}
}
- NativeMethods.cs
// this class just wraps some Win32 stuff that we're going to use
internal class NativeMethods
{
public const int HWND_BROADCAST = 0xffff;
public static readonly int WM_SHOWME = RegisterWindowMessage("WM_SHOWME");
[DllImport("user32")]
public static extern bool PostMessage(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam);
[DllImport("user32")]
public static extern int RegisterWindowMessage(string message);
}
- Form1.cs (lato anteriore parziale)
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;
}
}
Altri suggerimenti
Potresti usare la classe Mutex, ma scoprirai presto che dovrai implementare tu stesso il codice per passare gli argomenti e cose del genere.Bene, ho imparato un trucco durante la programmazione in WinForms mentre leggevo Il libro di Chris Sell.Questo trucco utilizza la logica che è già a nostra disposizione nel framework.Non so voi, ma quando imparo cose che posso riutilizzare nel framework, di solito questo è il percorso che prendo invece di reinventare la ruota.A meno che, ovviamente, non faccia tutto quello che voglio.
Quando sono entrato in WPF, ho trovato un modo per utilizzare lo stesso codice, ma in un'applicazione WPF.Questa soluzione dovrebbe soddisfare le tue esigenze in base alla tua domanda.
Per prima cosa dobbiamo creare la nostra classe applicativa.In questa classe sovrascriveremo l'evento OnStartup e creeremo un metodo chiamato Activate, che verrà utilizzato in seguito.
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();
}
}
In secondo luogo, dovremo creare una classe in grado di gestire le nostre istanze.Prima di procedere, riutilizzeremo parte del codice presente nell'assembly Microsoft.VisualBasic.Poiché in questo esempio utilizzo C#, ho dovuto fare riferimento all'assembly.Se stai utilizzando VB.NET, non devi fare nulla.La classe che utilizzeremo è WindowsFormsApplicationBase e ne erediterà il nostro gestore di istanze e quindi sfrutterà proprietà ed eventi per gestire la singola istanza.
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();
}
}
Fondamentalmente, stiamo utilizzando i bit VB per rilevare singole istanze ed elaborarle di conseguenza.OnStartup verrà attivato al caricamento della prima istanza.OnStartupNextInstance viene attivato quando l'applicazione viene eseguita nuovamente.Come puoi vedere, posso ottenere ciò che è stato passato sulla riga di comando tramite gli argomenti dell'evento.Ho impostato il valore su un campo di istanza.Puoi analizzare la riga di comando qui oppure passarla alla tua applicazione tramite il costruttore e la chiamata al metodo Activate.
Terzo, è il momento di creare il nostro EntryPoint.Invece di rinnovare l'applicazione come faresti normalmente, sfrutteremo il nostro SingleInstanceManager.
public class EntryPoint
{
[STAThread]
public static void Main(string[] args)
{
SingleInstanceManager manager = new SingleInstanceManager();
manager.Run(args);
}
}
Bene, spero che tu sia in grado di seguire tutto e di essere in grado di utilizzare questa implementazione e renderla tua.
Da Qui.
Un uso comune di un Mutex tra processi è garantire che solo un'istanza di un programma possa essere eseguita alla volta.Ecco come è fatto:
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 caratteristica positiva di Mutex è che se l'applicazione termina senza che venga prima chiamato ReleaseMutex, CLR rilascerà automaticamente il Mutex.
MSDN in realtà ha un'applicazione di esempio sia per C# che per VB per fare esattamente questo: http://msdn.microsoft.com/en-us/library/ms771662(v=VS.90).aspx
La tecnica più comune e affidabile per lo sviluppo del rilevamento a istanza singola è utilizzare l'infrastruttura di remoto di Microsoft .NET Framework (System.remoting).Microsoft .NET Framework (versione 2.0) include un tipo, WindowsFormSapplicationBase, che incapsula la funzionalità di remozione richiesta.Per incorporare questo tipo in un'applicazione WPF, un tipo deve derivare da esso ed essere utilizzato come spessore tra il metodo del punto di ingresso statico dell'applicazione, Main e il tipo di applicazione dell'applicazione WPF.Lo Shim rileva quando un'applicazione viene lanciata per la prima volta e quando vengono tentati i successivi lanci e i rendimenti controllano il tipo di applicazione WPF per determinare come elaborare i lanci.
- Per le persone C# basta fare un respiro profondo e dimenticare tutto "Non voglio includere VisualBasic DLL".Per colpa di Questo e cosa Scott Hanselman dice e il fatto che questa è praticamente la soluzione più pulita al problema ed è progettata da persone che sanno molto più di te sul framework.
- Dal punto di vista dell'usabilità il fatto è che se il tuo utente sta caricando un'applicazione ed è già aperta e gli stai dando un messaggio di errore come
'Another instance of the app is running. Bye'allora non saranno un utente molto felice.DEVI semplicemente (in un'applicazione GUI) passare a quell'applicazione e passare gli argomenti forniti - o se i parametri della riga di comando non hanno significato, devi far apparire l'applicazione che potrebbe essere stata ridotta a icona.
Il framework ha già il supporto per questo: è solo che qualche idiota ha chiamato la DLL Microsoft.VisualBasic e non è stato inserito Microsoft.ApplicationUtils o qualcosa di simile.Superalo o apri Reflector.
Mancia:Se usi questo approccio esattamente così com'è e hai già un App.xaml con risorse ecc.ti consigliamo di farlo dai un'occhiata anche a questo.
Questo codice dovrebbe andare al metodo principale.Guarda a Qui per ulteriori informazioni sul metodo main in 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;
}
}
Metodo 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 : I metodi sopra indicati presuppongono che il processo/applicazione abbia un nome univoco.Perché utilizza il nome del processo per trovare eventuali processori esistenti.Quindi, se la tua applicazione ha un nome molto comune (ad esempio:Blocco note), l'approccio sopra descritto non funzionerà.
Bene, ho una classe usa e getta per questo che funziona facilmente per la maggior parte dei casi d'uso:
Usalo in questo modo:
static void Main()
{
using (SingleInstanceMutex sim = new SingleInstanceMutex())
{
if (sim.IsOtherInstanceRunning)
{
Application.Exit();
}
// Initialize program here.
}
}
Ecco qui:
/// <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 nuovo che utilizza elementi Mutex e IPC e passa anche qualsiasi argomento della riga di comando all'istanza in esecuzione è Applicazione a istanza singola WPF.
Il codice Applicazione a istanza singola C# .NET questo è il riferimento per la risposta contrassegnata è un ottimo inizio.
Tuttavia, ho scoperto che non gestisce molto bene i casi in cui l'istanza già esistente ha una finestra di dialogo modale aperta, sia che quella finestra di dialogo sia gestita (come un altro modulo come una casella Informazioni) o non gestita (come il OpenFileDialog anche quando si utilizza la classe .NET standard).Con il codice originale, il modulo principale è attivato, ma quello modale rimane inattivo, il che sembra strano, inoltre l'utente deve cliccarci sopra per continuare a utilizzare l'app.
Quindi, ho creato una classe di utilità SingleInstance per gestire tutto questo in modo abbastanza automatico per le applicazioni Winforms e WPF.
Winform:
1) modificare la classe Program in questo modo:
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) modifica la classe della finestra principale in questo modo:
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) modifica la pagina dell'app in questo modo (e assicurati di impostare la sua azione di compilazione sulla pagina per poter ridefinire il metodo 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) modifica la classe della finestra principale in questo modo:
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;
}
Ed ecco la classe di utilità:
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);
}
}
}
Ecco un esempio che ti consente di avere una singola istanza di un'applicazione.Quando vengono caricate nuove istanze, passano i propri argomenti all'istanza principale in esecuzione.
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);
}
Solo alcuni pensieri:Ci sono casi in cui si richiede che solo un'istanza di un'applicazione non sia "zoppa" come alcuni vorrebbero far credere.App di database, ecc.sono un ordine di grandezza più difficili se si consente a più istanze dell'app per un singolo utente di accedere a un database (sai, tutto quell'aggiornamento di tutti i record aperti in più istanze dell'app sul computer dell'utente, ecc.) .Innanzitutto, per la "collisione dei nomi", non utilizzare un nome leggibile dall'uomo: utilizzare invece un GUID o, ancora meglio, un GUID + il nome leggibile dall'uomo.Le possibilità di collisione di nomi sono appena scomparse dal radar e al Mutex non importa.Come qualcuno ha sottolineato, un attacco DOS farebbe schifo, ma se la persona malintenzionata si è presa la briga di ottenere il nome mutex e incorporarlo nella sua app, sei comunque praticamente un bersaglio e dovrai fare MOLTO di più per proteggerti piuttosto che giocherellare con il nome del mutex.Inoltre, se si utilizza la variante di:new Mutex(true, "alcuni GUID più nome", out AIsFirstInstance), hai già l'indicatore se Mutex è o meno la prima istanza.
Tante risposte a una domanda così apparentemente semplice.Giusto per scuotere un po' le cose, ecco la mia soluzione a questo problema.
Creare un Mutex può essere problematico perché JIT-er vede che lo usi solo per una piccola parte del tuo codice e vuole contrassegnarlo come pronto per la garbage collection.Praticamente vuole farti superare in astuzia pensando che non utilizzerai quel Mutex per così tanto tempo.In realtà vuoi mantenere questo Mutex per tutto il tempo in cui la tua applicazione è in esecuzione.Il modo migliore per dire al netturbino di lasciarti in pace Mutex è dirgli di mantenerlo in vita nonostante le diverse generazioni di raccolta in garage.Esempio:
var m = new Mutex(...);
...
GC.KeepAlive(m);
Ho preso l'idea da questa pagina: http://www.ai.uga.edu/~mc/SingleInstance.html
Sembra che ci sia un ottimo modo per gestire questa situazione:
Applicazione a istanza singola WPF
Ciò fornisce una classe che puoi aggiungere che gestisce tutto il mutex e la messaggistica per semplificare l'implementazione fino al punto in cui è semplicemente banale.
Il codice seguente è la mia soluzione WCF denominata pipe per registrare un'applicazione a istanza singola.È carino perché genera anche un evento quando un'altra istanza tenta di avviarsi e riceve la riga di comando dell'altra istanza.
È orientato verso WPF perché utilizza il file System.Windows.StartupEventHandler class, ma questo potrebbe essere facilmente modificato.
Questo codice richiede un riferimento a PresentationFramework, E System.ServiceModel.
Utilizzo:
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.
}
}
Codice sorgente:
/// <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);
}
}
}
}
Non dovresti mai utilizzare un mutex denominato per implementare un'applicazione a istanza singola (o almeno non per il codice di produzione).Il codice dannoso può facilmente eseguire attacchi DoS (Negazione del servizio) il tuo culo...
Ecco cosa uso.Combinava l'enumerazione dei processi per eseguire la commutazione e il mutex per proteggersi dai "clicker attivi":
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();
}
}
Ho trovato la soluzione più semplice, simile a quella di Dale Ragan, ma leggermente modificata.Fa praticamente tutto ciò di cui hai bisogno e si basa sulla classe standard Microsoft WindowsFormsApplicationBase.
Innanzitutto, crei la classe SingleInstanceController, che puoi utilizzare in tutte le altre applicazioni a istanza singola, che utilizzano Windows Form:
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);
}
}
}
Quindi puoi usarlo nel tuo programma come 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();
}
}
}
Sia il programma che la soluzione SingleInstanceController_NET devono fare riferimento a Microsoft.VisualBasic .Se desideri semplicemente riattivare l'applicazione in esecuzione come una normale finestra quando l'utente tenta di riavviare il programma in esecuzione, il secondo parametro in SingleInstanceController può essere null.Nell'esempio fornito, la finestra è ingrandita.
Guarda il seguente codice.È una soluzione semplice ed efficace per impedire più istanze di un'applicazione 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();
}
}
Non usando Mutex però, risposta semplice:
System.Diagnostics;
...
string thisprocessname = Process.GetCurrentProcess().ProcessName;
if (Process.GetProcesses().Count(p => p.ProcessName == thisprocessname) > 1)
return;
Mettilo dentro Program.Main().
Esempio:
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());
}
}
}
Puoi aggiungere MessageBox.Show al if-istruzione e inserisci "Applicazione già in esecuzione".
Questo potrebbe essere utile a qualcuno.
Aggiornamento 25-01-2017. Dopo aver provato alcune cose, ho deciso di utilizzare VisualBasic.dll, è più semplice e funziona meglio (almeno per me).Lascio la mia risposta precedente solo come riferimento...
Giusto per riferimento, è così che ho fatto senza passare argomenti (cosa che non riesco a trovare alcun motivo per farlo...Intendo una singola app con argomenti tali da essere passati da un'istanza all'altra).Se è richiesta l'associazione di file, è necessario istanziare un'app (secondo le aspettative standard degli utenti) per ciascun documento.Se devi passare argomenti all'app esistente, penso che utilizzerei vb dll.
Non passando argomenti (solo app a istanza singola), preferisco non registrare un nuovo messaggio Window e non sovrascrivere il ciclo di messaggi come definito nella soluzione Matt Davis.Anche se non è un grosso problema aggiungere una DLL VisualBasic, preferisco non aggiungere un nuovo riferimento solo per eseguire un'app a istanza singola.Inoltre, preferisco istanziare una nuova classe con Main invece di chiamare Shutdown dall'override di App.Startup per assicurarmi di uscire il prima possibile.
Nella speranza che piaccia a qualcuno...o ispirerà un po' :-)
La classe di avvio del progetto deve essere impostata come "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);
Usa la soluzione 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;
}
}
}
}
}
Ecco una soluzione leggera che utilizzo che consente all'applicazione di portare in primo piano una finestra già esistente senza ricorrere a messaggi di Windows personalizzati o cercare ciecamente i nomi dei processi.
[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;
}
Modificare:Puoi anche archiviare e inizializzare mutex e createNew staticamente, ma dovrai eliminare/rilasciare esplicitamente il mutex una volta terminato.Personalmente preferisco mantenere il mutex locale in quanto verrà automaticamente eliminato anche se l'applicazione si chiude senza mai raggiungere la fine del Main.
Puoi anche usare il Runtime di CodeFluent che è un set di strumenti gratuito.Fornisce un Singola istanza classe per implementare un'applicazione a istanza singola.
Ecco la stessa cosa implementata tramite Event.
public enum ApplicationSingleInstanceMode
{
CurrentUserSession,
AllSessionsOfCurrentUser,
Pc
}
public class ApplicationSingleInstancePerUser: IDisposable
{
private readonly EventWaitHandle _event;
/// <summary>
/// Shows if the current instance of ghost is the first
/// </summary>
public bool FirstInstance { get; private set; }
/// <summary>
/// Initializes
/// </summary>
/// <param name="applicationName">The application name</param>
/// <param name="mode">The single mode</param>
public ApplicationSingleInstancePerUser(string applicationName, ApplicationSingleInstanceMode mode = ApplicationSingleInstanceMode.CurrentUserSession)
{
string name;
if (mode == ApplicationSingleInstanceMode.CurrentUserSession)
name = $"Local\\{applicationName}";
else if (mode == ApplicationSingleInstanceMode.AllSessionsOfCurrentUser)
name = $"Global\\{applicationName}{Environment.UserDomainName}";
else
name = $"Global\\{applicationName}";
try
{
bool created;
_event = new EventWaitHandle(false, EventResetMode.ManualReset, name, out created);
FirstInstance = created;
}
catch
{
}
}
public void Dispose()
{
_event.Dispose();
}
}
Gli approcci basati sul mutex denominato non sono multipiattaforma perché i mutex denominati non sono globali in Mono.Gli approcci basati sull'enumerazione dei processi non hanno alcuna sincronizzazione e possono provocare comportamenti errati (ad es.più processi avviati contemporaneamente possono terminare automaticamente a seconda dei tempi).Gli approcci basati su sistemi a finestre non sono desiderabili in un'applicazione console.Questa soluzione, basata sulla risposta di Divin, risolve tutti questi problemi:
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.");
}
}
}
}
Non riesco a trovare un soluzione breve ecco quindi spero che a qualcuno piaccia questo:
AGGIORNATO 2018-09-20
(A proposito.inserisci il codice in sei "Program.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;
}
// Codice opzionale.Se non vuoi che qualcuno lo esegua sei ".exe" con un nome diverso:
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());
}
Ho aggiunto un metodo sendMessage alla classe NativeMethods.
Apparentemente il metodo postmessage funziona, se l'applicazione non è visualizzata nella barra delle applicazioni, tuttavia l'utilizzo del metodo sendmessage risolve questo 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);
}
Di solito ogni volta che eseguiamo un file .exe, ogni volta crea un processo Windows separato con il proprio spazio di indirizzi, risorse e così via.Ma non vogliamo questo criterio perché ci impedirebbe di creare un processo unico.Le applicazioni a istanza singola possono essere create utilizzando Mutex in C# which è discusso in questo articolo
Inoltre se vogliamo portare l'applicazione in primo piano possiamo farlo utilizzando
[DllImport("user32")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);
Normalmente, questo è il codice che utilizzo per l'istanza singola Moduli Windows applicazioni:
[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());
}
}
}
Dove i componenti nativi sono:
[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
}
Ecco una soluzione:
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
È così che ho finito per occuparmi di questo problema.Tieni presente che il codice di debug è ancora lì per essere testato.Questo codice si trova all'interno di OnStartup nel file 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();
}
Questo potrebbe avere problemi che non ho ancora individuato.Se ne incontro qualcuno, aggiornerò la mia risposta.
