Comment redémarrer mon application C# WinForm ?

Question

Développement d'une application WinForm en C# .NET 2.0. J'ai besoin que l'application se ferme et redémarre d'elle-même.

Application.Restart();

La méthode ci-dessus a dont il est prouvé qu'il n'est pas fiable .

Quelle est la meilleure façon de redémarrer l'application ?

Answer 1

Une approche beaucoup plus simple qui a fonctionné pour moi est la suivante :

Application.Restart();
Environment.Exit(0);

Cela préserve les arguments de la ligne de commande et fonctionne malgré les gestionnaires d'événements qui empêcheraient normalement la fermeture de l'application.

L'appel Restart() tente de sortir, démarre quand même une nouvelle instance et revient. L'appel Exit() met ensuite fin au processus sans donner la chance aux gestionnaires d'événements de s'exécuter. Il y a une très brève période pendant laquelle les deux processus sont en cours d'exécution, ce qui n'est pas un problème dans mon cas, mais peut-être dans d'autres cas.

Le code de sortie 0 dans Environment.Exit(0); spécifie un arrêt propre. Vous pouvez également quitter avec 1 pour spécifier qu'une erreur s'est produite.

Answer 2

Si vous êtes dans le formulaire de l'application principale, essayez d'utiliser

System.Diagnostics.Process.Start( Application.ExecutablePath); // to start new instance of application
this.Close(); //to turn off current app

Answer 3

Malheureusement, vous ne pouvez pas utiliser Process.Start() pour démarrer une instance du processus en cours d'exécution. Selon la documentation de Process.Start() : "Si le processus est déjà en cours d'exécution, aucune ressource de processus supplémentaire n'est démarrée..."

Cette technique fonctionnera parfaitement sous le débogueur VS (parce que VS fait une sorte de magie qui fait croire à Process.Start que le processus n'est pas déjà en cours d'exécution), mais échouera si elle n'est pas exécutée sous le débogueur. (Notez que cela peut être spécifique au système d'exploitation - je crois me souvenir que dans certains de mes tests, cela a fonctionné sous XP ou Vista, mais je me souviens peut-être seulement de l'avoir exécuté sous le débogueur).

Cette technique est exactement celle utilisée par le dernier programmeur du projet sur lequel je travaille actuellement, et j'essaie de trouver une solution de contournement depuis un certain temps. Jusqu'à présent, je n'ai trouvé qu'une seule solution, qui me semble sale et peu pratique : lancer une deuxième application, qui attend en arrière-plan que la première application se termine, puis relance la première application. Je suis sûr que ça pourrait fonctionner, mais, beurk.

Edit : Utiliser une 2ème application fonctionne. Tout ce que j'ai fait dans la seconde application était :

    static void RestartApp(int pid, string applicationName )
    {
        // Wait for the process to terminate
        Process process = null;
        try
        {
            process = Process.GetProcessById(pid);
            process.WaitForExit(1000);
        }
        catch (ArgumentException ex)
        {
            // ArgumentException to indicate that the 
            // process doesn't exist?   LAME!!
        }
        Process.Start(applicationName, "");
    }

(Il s'agit d'un exemple très simplifié. Le vrai code comporte de nombreux contrôles d'intégrité, de gestion des erreurs, etc.)

Answer 4

Je suis peut-être en retard, mais voici ma solution simple, qui fonctionne à merveille avec toutes les applications dont je dispose :

        try
        {
            //run the program again and close this one
            Process.Start(Application.StartupPath + "\\blabla.exe"); 
            //or you can use Application.ExecutablePath

            //close this one
            Process.GetCurrentProcess().Kill();
        }
        catch
        { }

Answer 5

J'ai eu exactement le même problème et j'avais moi aussi l'obligation d'empêcher les instances dupliquées - je propose une solution alternative à celle de HiredMind (qui fonctionnera très bien).

Ce que je fais, c'est démarrer le nouveau processus avec le processId de l'ancien processus (celui qui déclenche le redémarrage) comme argument de ligne de commande :

// Shut down the current app instance.
Application.Exit();

// Restart the app passing "/restart [processId]" as cmd line args
Process.Start(Application.ExecutablePath, "/restart" + Process.GetCurrentProcess().Id);

Ensuite, lorsque la nouvelle application démarre, j'analyse d'abord les arguments de la ligne cm et je vérifie si le drapeau de redémarrage est présent avec un processId, puis j'attends que le processus se termine :

if (_isRestart)
{
   try
   {
      // get old process and wait UP TO 5 secs then give up!
      Process oldProcess = Process.GetProcessById(_restartProcessId);
      oldProcess.WaitForExit(5000);
   }
   catch (Exception ex)
   { 
      // the process did not exist - probably already closed!
      //TODO: --> LOG
   }
}

Je ne montre évidemment pas tous les contrôles de sécurité que j'ai mis en place, etc.

Même si ce n'est pas idéal, je trouve que c'est une alternative valable pour ne pas avoir à mettre en place une application séparée juste pour gérer le redémarrage.