Starten Sie eine Anwendung von selbst

Will ich bauen meine Anwendung mit der Funktion neu zu starten. Fand ich auf codeproject

ProcessStartInfo Info=new ProcessStartInfo();
Info.Arguments="/C choice /C Y /N /D Y /T 3 & Del "+
               Application.ExecutablePath;
Info.WindowStyle=ProcessWindowStyle.Hidden;
Info.CreateNoWindow=true;
Info.FileName="cmd.exe";
Process.Start(Info); 
Application.Exit();

Das funktioniert nicht bei allen...
Und das andere problem ist, wie Sie ihn wieder starten wollen?
Vielleicht gibt es auch Argumente, die zum starten von Anwendungen.

Edit:

http://www.codeproject.com/script/Articles/ArticleVersion.aspx?aid=31454&av=58703

InformationsquelleAutor der Frage Noli | 2012-03-07

38

Ich benutze ähnlichen code, um den code, den Sie versucht, beim starten von apps. Ich sende eine zeitlich cmd Befehl starten Sie die app für mich so:
```
ProcessStartInfo Info = new ProcessStartInfo();
Info.Arguments = "/C ping 127.0.0.1 -n 2 && \"" + Application.ExecutablePath + "\"";
Info.WindowStyle = ProcessWindowStyle.Hidden;
Info.CreateNoWindow = true;
Info.FileName = "cmd.exe";
Process.Start(Info);
Application.Exit(); 
```
Den Befehl an das OS, das ping-hält das script für 2-3 Sekunden, wenn die Anwendung beendet hat, aus Application.Exit()dann wird der nächste Befehl nach dem ping wieder gestartet.

Hinweis: Die \" setzt Anführungszeichen um den Pfad herum, incase es hat Räume, die cmd kann nicht verarbeiten, ohne Anführungszeichen.

Hoffe, das hilft!

InformationsquelleAutor der Antwort Bali C
26

Warum nicht
```
Application.Restart();
```
??

Mehr auf Neu starten

InformationsquelleAutor der Antwort Shai
9

Warum nicht einfach Folgendes?
```
Process.Start(Application.ExecutablePath); 
Application.Exit();
```
Wenn Sie sicherstellen möchten, dass die app nicht zweimal ausgeführt wird, verwenden Sie entweder Environment.Exit(-1) das tötet den Prozess unmittelbar (nicht wirklich die nette Art) oder etwas wie der Beginn einer zweiten app, die überprüft, für den Prozess der Haupt-app und startet ihn wieder, sobald der Prozess Weg ist.

InformationsquelleAutor der Antwort ChrFin
6

Haben Sie der ersten Anwendung Ein, die Sie neu starten möchten.
Also, Wenn Sie wollen, zu töten, eine kleine Applikation B wird gestartet, B töte A, dann B start A und töte B.

Um einen Prozess zu starten:
```
Process.Start("A.exe");
```
Töten einen Prozess, ist so etwas wie das
```
Process[] procs = Process.GetProcessesByName("B");

foreach (Process proc in procs)
   proc.Kill();
```
InformationsquelleAutor der Antwort Mentezza
3

Winforms hat die Anwendung.Restart() Methode, die genau das tut. Wenn Sie mit WPF können Sie einfach fügen Sie einen Verweis auf System.Windows.Forms und nennen es.

InformationsquelleAutor der Antwort Avner Shahar-Kashtan

Eine Menge Leute sind darauf hindeutet, zu Anwendung.Neu starten. In der Realität, diese Funktion nur selten führt wie erwartet. Ich habe noch nie hatte es ein Herunterfahren der Anwendung rufe ich es aus. Ich hatte schon immer die Anwendung schließen, die durch andere Methoden wie die Schließung der Haupt-form.

Haben Sie zwei Möglichkeiten des Umgangs mit diesen. Sie haben entweder ein externes Programm, das schließt den aufrufenden Prozess und beginnt ein neues,

oder,

haben Sie den start Ihres neuen software-töten andere Instanzen der gleichen Anwendung, wenn ein argument übergeben wird, als neu zu starten.

        private void Application_Startup(object sender, StartupEventArgs e)
        {
            try
            {
                if (e.Args.Length > 0)
                {
                    foreach (string arg in e.Args)
                    {
                        if (arg == "-restart")
                        {
                            //WaitForConnection.exe
                            foreach (Process p in Process.GetProcesses())
                            {
                                //In case we get Access Denied
                                try
                                {
                                    if (p.MainModule.FileName.ToLower().EndsWith("yourapp.exe"))
                                    {
                                        p.Kill();
                                        p.WaitForExit();
                                        break;
                                    }
                                }
                                catch
                                { }
                            }
                        }
                    }
                }
            }
            catch
            {
            }
        }

InformationsquelleAutor der Antwort JeremyK

1

Einen anderen Weg, dies zu tun, fühlt sich ein wenig sauberer als bei diesen Lösungen ist zum ausführen einer batch-Datei, die eine bestimmte Verzögerung zu warten, bis die aktuelle Anwendung zu beenden. Dies hat den zusätzlichen Vorteil der Verhinderung der Antrag in zwei Instanzen nicht öffnen zur gleichen Zeit.

Beispiel windows batch-Datei ("neu starten.Fledermaus"):
```
sleep 5
start "" "C:\Dev\MyApplication.exe"
```
In der Anwendung, fügen Sie diesen code:
```
//Launch the restart batch file
Process.Start(@"C:\Dev\restart.bat");

//Close the current application (for WPF case)
Application.Current.MainWindow.Close();

//Close the current application (for WinForms case)
Application.Exit();
```
InformationsquelleAutor der Antwort dodgy_coder

Meine Lösung:

        private static bool _exiting;
    private static readonly object SynchObj = new object();

        public static void ApplicationRestart(params string[] commandLine)
    {
        lock (SynchObj)
        {
            if (Assembly.GetEntryAssembly() == null)
            {
                throw new NotSupportedException("RestartNotSupported");
            }

            if (_exiting)
            {
                return;
            }

            _exiting = true;

            if (Environment.OSVersion.Version.Major < 6)
            {
                return;
            }

            bool cancelExit = true;

            try
            {
                List<Form> openForms = Application.OpenForms.OfType<Form>().ToList();

                for (int i = openForms.Count - 1; i >= 0; i--)
                {
                    Form f = openForms[i];

                    if (f.InvokeRequired)
                    {
                        f.Invoke(new MethodInvoker(() =>
                        {
                            f.FormClosing += (sender, args) => cancelExit = args.Cancel;
                            f.Close();
                        }));
                    }
                    else
                    {
                        f.FormClosing += (sender, args) => cancelExit = args.Cancel;
                        f.Close();
                    }

                    if (cancelExit) break;
                }

                if (cancelExit) return;

                Process.Start(new ProcessStartInfo
                {
                    UseShellExecute = true,
                    WorkingDirectory = Environment.CurrentDirectory,
                    FileName = Application.ExecutablePath,
                    Arguments = commandLine.Length > 0 ? string.Join(" ", commandLine) : string.Empty
                });

                Application.Exit();
            }
            finally
            {
                _exiting = false;
            }
        }
    }

InformationsquelleAutor der Antwort Martin.Martinsson

Für .Net-Anwendung, die Lösung sieht wie folgt aus:

System.Web.HttpRuntime.UnloadAppDomain()

Ich diese verwendet, um starten Sie in meinem web-Anwendung nach der änderung AppSettings in der Datei myconfig.

System.Configuration.Configuration configuration = WebConfigurationManager.OpenWebConfiguration("~");
configuration.AppSettings.Settings["SiteMode"].Value = model.SiteMode.ToString();
configuration.Save();

InformationsquelleAutor der Antwort Pal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.