AGB  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Code-Bibliothek Library: Windows API / MS.NET Framework API Prism Anwendung starten und warten bis diese beendet ist

Anwendung starten und warten bis diese beendet ist

Ein Thema von Sprint · begonnen am 27. Dez 2004 · letzter Beitrag vom 19. Jan 2005
Antwort Antwort
Benutzerbild von Sprint
Sprint

Registriert seit: 18. Aug 2004
Ort: Edewecht
712 Beiträge
 
Delphi 5 Professional
 
#1

Anwendung starten und warten bis diese beendet ist

  Alt 27. Dez 2004, 23:54
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]
Ciao, Sprint.

"I don't know what I am doing, but I am sure I am having fun!"
  Mit Zitat antworten Zitat
Benutzerbild von flomei
flomei

Registriert seit: 17. Jan 2003
Ort: Schieder-Schwalenberg
2.094 Beiträge
 
Delphi 2005 Personal
 
#2

Re: [.NET] Anwendung starten und warten bis diese beendet is

  Alt 19. Jan 2005, 16:31
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]
Angehängte Dateien
Dateityp: dll delphipraxis.codelib.threadedprocess_182.dll (16,0 KB, 40x aufgerufen)
Dateityp: txt documentation.chm.umbenannt_704.txt (20,8 KB, 57x aufgerufen)
Florian Meier
... ist raus.
Vielen Dank für die Zeit mit euch!
http://www.flomei.de -- http://www.md5hash.de
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 02:25 Uhr.
Powered by vBulletin® Copyright ©2000 - 2014, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2014 by Daniel R. Wolf