À l'aide de waitone() la méthode

static Mutex mutex = new Mutex (false, "oreilly.com OneAtATimeDemo");

static void Main()
{
    //Wait a few seconds if contended, in case another instance
    //of the program is still in the process of shutting down.

    if (!mutex.WaitOne (TimeSpan.FromSeconds (3), 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(); }
}

http://www.albahari.com/nutshell/ch20.aspx

Dans ce code:

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

http://sanity-free.org/143/csharp_dotnet_single_instance_application.html

Il n'y a pas d'inversion de la si/bool.

Si waitone() est vrai, cela signifie qu'une instance est déjà en cours d'exécution? Si true est retourné, le thread en cours sera bloqué, ce qui aboutirait à deux processus de l'appel de la même application permettra à la fois de stopper?

Ma compréhension est comme suit:

//Don't block the thread while executing code. 
//Let the code finish and then signal for another process to enter

Quelle est l'implication de pas de ! (de retour) et vice versa. Ou en d'autres termes, qu'advient-il de toute façon?

Je sais waitAll par exemple, vous attend pour tous les threads à la fin. Jon Skeet a montré un bon exemple de cela sur son site, ce qui a coincé dans mon esprit (crédit à ses explications). Alors, évidemment, waitOne attend pour un fil à la fin. La valeur de retour est ce qui me confond.

OriginalL'auteur dotnetdev | 2009-05-02

  1. 18

    Attendre sur un mutex signifie d'attendre jusqu'à ce que vous pouvez acquérir.

    WaitOne sur un Mutex sera de retour true si le mutex peut être acquis dans le temps donné. Si elle ne le pouvait pas, la méthode retournera false. Si le mutex a été acquis, il est de votre responsabilité de libérer le mutex lorsque vous avez terminé avec elle.

    Si vous pouvez acquérir un mutex nommé, personne d'autre ne le possède pour le moment.

    Donc, pour récapituler. Si vous pouvez acquérir le mutex, la méthode renvoie true et vous êtes le premier/seule instance de votre application, en ce qui concerne votre question.

    Si vous ne pouvez pas acquérir le mutex, la méthode renvoie false et il y a une autre instance de l'application possédant le mutex de ce nom.

    OriginalL'auteur Lasse Vågsæther Karlsen

  2. 1

    Dans la MSDN la description de mutex.WaitOne() est-ce:

    Bloque le thread courant jusqu'à ce que le
    actuel WaitHandle reçoit un signal.

    Et la valeur de retour est: true si l'instance courante reçoit un signal

    Donc, jusqu'à ce que l'application est démarrée une fois, il ne reçoit aucun signal de la sourdine.WaitOne() la méthode. Le thread est bloqué, comme il est dit dans la description.

    Donc, pour répondre à votre question:

    Quelle est l'implication de pas de ! (de retour) et vice versa.

    Si vous nier le mutex.WaitOne() la méthode, alors vous allez vérifier: Si PAS waitOne(), cela signifie que vous vérifiez si le waitOne ne pas répondre avec vrai.

    J'espère que c'est plus clair maintenant.

    OriginalL'auteur Timotei