Anwendung starten und warten bis diese beendet ist

[Sprint]

Delphi-Quellcode:

uses
  System.Diagnostics;

Delphi-Quellcode:

function RunAppAndWait(const AFileName: string): Boolean;
var
  NewProcess: Process;
begin

  NewProcess := Process.Create;
  with NewProcess do
  begin
    StartInfo.FileName := AFileName;
    try
      Result := Start;
      while (not HasExited) do
      begin
        WaitForExit(125);
        Application.DoEvents;
      end;
    except
      Result := False;
    end; {end try/except}
  end; {end with}

end; {end function}

[edit=Chakotay1308]Titel angepasst. Mfg, Chakotay1308[/edit]

[flomei]

Folgende Ergänzung traf von Robert_G ein:

Zitat von Robert_G:

Der code in der CodeLib lief immer in einer Schleife und sendete DoEvents(); ohne Ende.
Viel sinnvoller finde ich es, wenn man einen Event nach dem Starten und einen nach dem Beenden bekommt.
Das Warten wird in einem Thread abgearbeitet.

Ich habe noch schnell ein paar Doku-Tags angefügt und die durch nDoc gejagt. (siehe anhang)

Code:

using System;
using System.Diagnostics;


namespace DelphiPRAXIS.Samples
{
    /// <summary>
    /// <see cref="Delegate"/> für die beiden events <see cref="ThreadedProcess.Started"/> und <see cref="ThreadedProcess.Finished"/>.
    /// </summary>
    public delegate void ProcessStateHandler(object sender, EventArgs e);

    /// <summary>
    /// Summary description for ThreadedProcess.
    /// </summary>
    public class ThreadedProcess
    {
        #region Events

        /// <summary>
        /// Wird vor dem Ausführen (<see cref="Run"/>) durchlaufen.
        /// </summary>
        public event ProcessStateHandler Started;

        /// <summary>
        /// Wird nach dem Ausführen (<see cref="Run"/>) durchlaufen.
        /// </summary>
        public event ProcessStateHandler Finished;

        void OnStarted(EventArgs e)
        {
            if (Started != null)
            {
                Started(this, e);
            }
        }

        void OnFinished(EventArgs e)
        {
            if (Finished != null)
            {
                Finished(this, e);
            }
        }

        #endregion

        #region Fields

        string[] arguments;
        string executable;

        #endregion

        #region Properties

        /// <summary>
        /// Die Argumente, die der <see cref="Executable"/> übergeben werden. (optional)
        /// </summary>
        public string[] Arguments
        {
            get { return arguments; }
            set
            {
                if (value == null)
                {
                    arguments = new string[0];
                } else
                {
                    arguments = value;
                }
            }
        }

        /// <summary>
        /// Die auszuführende Datei
        /// </summary>
        public string Executable
        {
            get { return executable; }
            set { executable = value; }
        }

        #endregion

        #region Constructors

        /// <summary>
        /// Constructor, der beide Felder initialisiert.
        /// </summary>
        /// <param name="executable"><see cref="Executable"/></param>
        /// <param name="arguments"><see cref="Arguments"/></param>
        public ThreadedProcess(string executable, params string[] arguments)
        {
            this.arguments = arguments;
            this.executable = executable;
        }

        #endregion

        /// <summary>
        /// Der gekapselte <see cref="Process"/> wird in einem <see cref="System.Threading.Thread">Thread</see>
        /// ausgeführt.
        /// Gestartet wird <see cref="Executable"/> mit optionalen <see cref="Arguments">Argumenten</see>.
        /// </summary>
        /// <remarks>Vor dem Ausführen wird <see cref="Started"/> aufgerufen, nach dem Beenden <see cref="Finished"/>.</remarks>
        /// <example>Kleines Beispiel zur Verwendung
        /// <code>
        ///using System;
        /// 
        ///namespace DelphiPRAXIS.Samples.Threading.TestConsole
        ///{
        ///  internal class Program
        ///  {
        ///    static void Main(string[] args)
        ///    {
        ///      Program program = new Program();
        ///      if (args.GetLength(0) > 0)
        ///      {
        ///        program.RunProcess("delphi32.exe", args);
        ///      }
        ///    }
        ///   
        ///    void ProcessStarted(object sender, EventArgs e)
        ///    {
        ///      ThreadedProcess process = sender as ThreadedProcess;
        ///      Console.WriteLine("running \"{0}\" using {1}...",
        ///                        process.Executable,
        ///                        string.Join(", ", process.Arguments));
        ///    }
        ///   
        ///    void ProcessFinished(object sender, EventArgs e)
        ///    {
        ///      ThreadedProcess process = sender as ThreadedProcess;
        ///      Console.WriteLine("finished running \"{0}\" using {1}...",
        ///                        process.Executable,
        ///                        string.Join(", ", process.Arguments));
        ///      Console.ReadLine();
        ///    }
        ///   
        ///    void RunProcess(string executable, params string[] arguments)
        ///    {
        ///      ThreadedProcess process = new ThreadedProcess(executable, arguments);
        ///      process.Started += new ProcessStateHandler(ProcessStarted);
        ///      process.Finished += new ProcessStateHandler(ProcessFinished);
        ///      process.Run();
        ///    }
        ///  }
        ///}</code></example>
        public void Run()
        {
            OnStarted(EventArgs.Empty);
            Process process = new Process();
            process.StartInfo.FileName = executable;
            process.StartInfo.Arguments = string.Join(" ",
                                                      arguments);
            process.Start();
            process.WaitForExit();
            OnFinished(EventArgs.Empty);
        }
    }
}

Sicher wären spezielle EventArgs ganz nett, die zum Beispiel den Exitcode,.... ausgeben. Aber dafür hatte ich jetzt keine Lust.

Dazu noch zwei Dateien.

MFG Florian

[edit=Chakotay1308]Code-Tags korrigiert. Mfg, Chakotay1308[/edit]