Exécuter une instance de l'application

Question

J'ai une application Windows (C #) et je dois le configurer pour exécuter une instance de l'application à l'époque, cela signifie qu'un utilisateur a cliqué sur le fichier .exe et l'application est exécutée et l'utilisateur n'a pas fermé la première instance de l'application qui est en cours d'exécution et la nécessité d'exécuter une instance suivante de sorte qu'il devrait apparaître la première instance et de ne pas ouvrir un nouveau.

peut me aider comment faire?

merci à l'avance

Answer 1

Je résous souvent en vérifiant d'autres processus avec le même nom. L'avantage / inconvénient est que vous (ou l'utilisateur) peut « se retirer » du chèque en renommant l'exe. Si vous ne voulez pas que vous pouvez probablement utiliser le processus objet qui est retourné.

  string procName = Process.GetCurrentProcess().ProcessName;
  if (Process.GetProcessesByName(procName).Length == 1)
  {
      ...code here...
  }

Cela dépend de votre besoin, je pense qu'il est à portée de main pour contourner le contrôle subjets recompiler (c'est un processus serveur, ce qui est parfois exécuté en tant que service).

Answer 2

L'équipe VB.Net a déjà mis en œuvre une solution. Vous aurez besoin de prendre une dépendance à l'égard Microsoft.VisualBasic.dll, mais si cela ne vous dérange pas, alors c'est une bonne solution à mon humble avis. Voir la fin de l'article suivant: instance unique Apps

Voici les parties pertinentes de l'article:

1) Ajouter une référence à Microsoft.VisualBasic.dll 2) Ajoutez la classe suivante à votre projet.

public class SingleInstanceApplication : WindowsFormsApplicationBase
{
    private SingleInstanceApplication()
    {
        base.IsSingleInstance = true;
    }

    public static void Run(Form f, StartupNextInstanceEventHandler startupHandler)
    {
        SingleInstanceApplication app = new SingleInstanceApplication();
        app.MainForm = f;
        app.StartupNextInstance += startupHandler;
        app.Run(Environment.GetCommandLineArgs());
    }
}

Ouvrir Program.cs et ajoutez l'instruction using suivante:

using Microsoft.VisualBasic.ApplicationServices;

Modifier la classe à ce qui suit:

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        SingleInstanceApplication.Run(new Form1(), StartupNextInstanceEventHandler);
    }

    public static void StartupNextInstanceEventHandler(object sender, StartupNextInstanceEventArgs e)
    {
        MessageBox.Show("New instance");
    }
}

Answer 3

Edit: Après a été modifié à la question d'inclure c #. Ma réponse ne fonctionne que pour l'application de vb.net

sélectionnez Faire application seule instance case à cocher pour empêcher les utilisateurs d'exécuter plusieurs instances de votre application. Le réglage par défaut pour cette case à cocher est désactivée, ce qui permet plusieurs instances de l'application à exécuter.

Vous pouvez le faire à partir du projet -> Propriétés -> onglet Application

Source

Answer 4

Nous avons eu exactement le même problème. Nous avons essayé l'approche processus, mais cela ne fonctionne pas, si l'utilisateur n'a pas le droit de lire des informations sur d'autres processus, à savoir les non-administrateurs. Nous avons donc mis en œuvre la solution ci-dessous.

En fait, nous essayons d'ouvrir un fichier pour la lecture exclusive. Si cela échoue (parce anohter instance a déjà fait), nous obtenons une exception et peut quitter l'application.

        bool haveLock = false;
        try
        {
            lockStream = new System.IO.FileStream(pathToTempFile,System.IO.FileMode.Create,System.IO.FileAccess.ReadWrite,System.IO.FileShare.None);
            haveLock = true;
        }
        catch(Exception)
        {
            System.Console.WriteLine("Failed to acquire lock. ");
        }
        if(!haveLock)
        {
            Inka.Controls.Dialoge.InkaInfoBox diag = new Inka.Controls.Dialoge.InkaInfoBox("App has been started already");
            diag.Size = new Size(diag.Size.Width + 40, diag.Size.Height + 20);
            diag.ShowDialog();
            Application.Exit();
        }

Answer 5

En supposant que vous utilisez C #

        static Mutex mx;
        const string singleInstance = @"MU.Mutex";
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            try
            {
                System.Threading.Mutex.OpenExisting(singleInstance);
                MessageBox.Show("already exist instance");
                return;
            }
            catch(WaitHandleCannotBeOpenedException)
            {
                mx = new System.Threading.Mutex(true, singleInstance);

            }
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());
        }

Answer 6

J'utilise un Mutex pour ce scénario. Alternativement, un Semaphore travaillerait aussi (mais un Mutex semble plus apte).

Voici mon exemple (d'une application WPF, mais les mêmes principes devraient appliquer à d'autres types de projets):

public partial class App : Application
{
    const string AppId = "MY APP ID FOR THE MUTEX";
    static Mutex mutex = new Mutex(false, AppId);
    static bool mutexAccessed = false;

    protected override void OnStartup(StartupEventArgs e)
    {
        try
        {
            if (mutex.WaitOne(0))
                mutexAccessed = true;
        }
        catch (AbandonedMutexException)
        {
            //handle the rare case of an abandoned mutex
            //in the case of my app this isn't a problem, and I can just continue
            mutexAccessed = true;
        }

        if (mutexAccessed)
            base.OnStartup(e);
        else
            Shutdown();
    }

    protected override void OnExit(ExitEventArgs e)
    {
        if (mutexAccessed)
            mutex?.ReleaseMutex();

        mutex?.Dispose();
        mutex = null;
        base.OnExit(e);
    }
}

Answer 7

J'ai trouvé ce , c'est un travail!

 /// <summary>
        /// The main entry point for the application.
        /// Limit an app.to one instance
        /// </summary>
        [STAThread]
        static void Main()
        {
            //Mutex to make sure that your application isn't already running.
            Mutex mutex = new System.Threading.Mutex(false, "MyUniqueMutexName");
            try
            {
                if (mutex.WaitOne(0, false))
                {
                    // Run the application
                    Application.EnableVisualStyles();
                    Application.SetCompatibleTextRenderingDefault(false);
                    Application.Run(new Form1());
                }
                else
                {
                    MessageBox.Show("An instance of the application is already running.",
                        "An Application Is Running", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Application Error 'MyUniqueMutexName'", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            finally
            {
                if (mutex != null)
                {
                    mutex.Close();
                    mutex = null;
                }
            }
        }