Come pianificare un Process.Start in WPF

Question

Sto cercando di riavviare un'applicazione in WPF.

ho provato il seguente:

Process.Start(Application.ExecutablePath);
Process.GetCurrentProcess().Kill();

E non funziona perché l'applicazione è configurato come una singola applicazione casi.

Poi mi stanco in questo modo:

Process.GetCurrentProcess().Kill();
Process.Start(Application.ExecutablePath);

E non funziona perché una volta che noi uccidiamo il processo non sarà colpito la linea 2

C'è un modo per programmare un l'.Start in modo che io non incorrere in problema # 1.

Answer 1

Si potrebbe lanciare un'applicazione secondaria che avrebbe poi ri-avviare il programma principale dopo il ritardo. Quando ho scritto un auto-updater pochi anni fa, che è stato il percorso di implementazione che ho preso. E 'stato solo un semplice programma che ha preso l'eseguibile come una riga di comando arg, avrebbe dormito per un decimo di secondo, poi .Start esso.

Un percorso migliore attuazione di quanto ho preso sarebbe quello di avere il programma appena lanciato attesa per il processo che ha lanciato per terminare. Aspettando la lunghezza arbitraria di tempo potrebbe complicare le cose. Al fine di raggiungere questo obiettivo, probabilmente passare l'ID del processo per la ri-launcher in modo che sarebbe sapere esattamente quale processo di aspettare.

Answer 2

Non è così difficile come si pensa. Tutto quello che dovete fare è chiamare il metodo seguente, passando nella riga di comando per l'istanza riavviato:

public static void RestartMe(string commandLine)
{
  var myId = Process.GetCurrentProcess().Id;
  var myPath = Assembly.GetEntryAssembly().CodeBase.Replace("file:///", "");
  var systemPath = typeof(object).Assembly.CodeBase.Replace("file:///", "");

  var tempPath = Path.GetTempFileName();

  File.WriteAllText(tempPath + ".cs", @"
    using System;
    using System.Diagnostics;
    public class App
    {
      public static void Main(string[] args)
      {
        try { Process.GetProcessById(" + myId + @").WaitForExit(); } catch {}
        Process.Start(""" + myPath + @""", Environment.CommandLine);
      }
    }");

  var compiler = new ProcessStartInfo
  {
    FileName = Path.Combine(Path.GetDirectoryName(systemPath), "csc.exe"),
    Arguments = tempPath + ".cs",
    WorkingDirectory = Path.GetDirectoryName(tempPath),
    WindowStyle = ProcessWindowStyle.Hidden,
  };

  var restarter = new ProcessStartInfo
  {
    FileName = tempPath + ".exe",
    Arguments = commandLine,
    WindowStyle = ProcessWindowStyle.Hidden,
  };

  Process.Start(compiler).WaitForExit();
  Process.Start(restarter); // No WaitForExit: restarter WaitForExits us instead

  File.Delete(tempPath);
  File.Delete(tempPath + ".cs");
  Environment.Exit(0);
}

Come funziona: Questo non fa effettivamente creare un altro programma "restarter", ma lo fa in modo indolore e automatico. Il programma restarter ha l'ID del processo corrente e il nome del file eseguibile costruito a destra in esso. Sarà sempre trovare il compilatore perché NET Framework versione fornita con un csc.exe compatibili nella stessa cartella come System.dll.