Utilise un Mutex pour éviter que plusieurs instances d'un même programme en cours d'exécution en sécurité?

En général oui cela fonctionnera. Cependant, le diable est dans les détails.

Tout d'abord, vous voulez fermer le mutex dans un finally bloc. Sinon votre processus pourrait se terminer brusquement et le laisser dans un état signalé, comme une exception. Qu'allait-il faire en sorte que les futures instances de processus ne serait pas en mesure de démarrer.

Malheureusement, même avec un finally bloc vous devez traiter avec le potentiel qu'un processus sera terminé sans libérer le mutex. Cela peut arriver par exemple si un utilisateur supprime le processus via le gestionnaire des tâches. Il est une condition de concurrence dans votre code, ce qui permettrait une deuxième processus pour obtenir un AbandonedMutexException dans le WaitOne appel. Vous aurez besoin d'un programme de rétablissement pour cette.

Je vous encourage à lire sur les détails de la classe Mutex. L'aide il n'est pas toujours simple.

---

Étendre sur la condition de la course possibilité:

La séquence suivante d'événements peuvent se produire qui serait la cause d'une deuxième instance de l'application à lancer:

1. Procédure normale de démarrage.
2. Deuxième processus démarre et acquiert une poignée pour le mutex, mais est mis à l'écart avant la WaitOne appel.
3. Processus #1 est brusquement interrompu. Le mutex n'est pas détruit parce que le processus 2 a une poignée. C'est plutôt à un état d'abandon.
4. Le deuxième processus commence à courir à nouveau et obtient un AbanonedMutexException.

Vous pouvez utiliser un mutex, mais assurez-vous d'abord que c'est vraiment ce que vous voulez.

Parce que "en évitant de multiples instances" n'est pas clairement défini. Il peut signifier

1. En évitant plusieurs instances a commencé dans la même session de l'utilisateur, peu importe le nombre de postes de travail que la session utilisateur a, mais permettant à de multiples instances de l'exécution simultanée de plusieurs sessions d'utilisateur.
2. En évitant plusieurs instances a commencé dans le même bureau, mais en permettant à de multiples instances d'exécuter en tant que chacun est dans un bureau séparé.
3. En évitant plusieurs instances a commencé pour le même compte d'utilisateur, peu importe le nombre d'ordinateurs de bureau ou des sessions en cours d'exécution en vertu de ce compte existe, mais en permettant à de multiples instances d'exécuter simultanément pour les sessions exécute sous un compte d'utilisateur différent.
4. En évitant plusieurs instances commencé sur la même machine. Cela signifie que peu importe combien de postes de travail sont utilisés par un nombre arbitraire d'utilisateurs, il peut y avoir au plus une occurrence de programme en cours d'exécution.

À l'aide d'un mutex, vous êtes essentiellement en utilisant le définir le nombre 4.

Sur Windows, l'arrêt d'un processus a les résultats suivants:

• Toutes les autres threads du processus sont marqués pour la résiliation.
• Des ressources allouées par le processus sont libérés.
• Tous les objets de noyau sont fermés.
• Le processus de code est supprimé de la mémoire.
• Le code de sortie du processus est défini.
• L'objet de processus est signalé.

Mutex les objets sont les objets de noyau, de sorte que tout détenu par un processus sont fermés lorsque le processus se termine (sous Windows en tout cas).

Mais, note le bit suivant de la CreateMutex() docs:

Si vous utilisez un mutex nommé à la limite de votre application à un seul exemple, un utilisateur malveillant peut créer ce mutex avant de le faire et de prévenir de votre demande de départ.

Voici l'extrait de code

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

Utiliser l'application avec le délai d'attente et les paramètres de sécurité en évitant AbandonedMutexException. J'ai utilisé ma classe personnalisée:

private class SingleAppMutexControl : IDisposable
    {
        private readonly Mutex _mutex;
        private readonly bool _hasHandle;

        public SingleAppMutexControl(string appGuid, int waitmillisecondsTimeout = 5000)
        {
            bool createdNew;
            var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
                MutexRights.FullControl, AccessControlType.Allow);
            var securitySettings = new MutexSecurity();
            securitySettings.AddAccessRule(allowEveryoneRule);
            _mutex = new Mutex(false, "Global\\" + appGuid, out createdNew, securitySettings);
            _hasHandle = false;
            try
            {
                _hasHandle = _mutex.WaitOne(waitmillisecondsTimeout, false);
                if (_hasHandle == false)
                    throw new System.TimeoutException();
            }
            catch (AbandonedMutexException)
            {
                _hasHandle = true;
            }
        }

        public void Dispose()
        {
            if (_mutex != null)
            {
                if (_hasHandle)
                    _mutex.ReleaseMutex();
                _mutex.Dispose();
            }
        }
    }

et de l'utiliser:

    private static void Main(string[] args)
    {
        try
        {
            const string appguid = "{xxxxxxxx-xxxxxxxx}";
            using (new SingleAppMutexControl(appguid))
            {
                //run main app
                Console.ReadLine();
            }
        }
        catch (System.TimeoutException)
        {
            Log.Warn("Application already runned");
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Fatal Error on running");
        }
    }