Programm starten und warten bis es beendet wird

[meisteralex]

Hi Leute ich habe mehrere Fragen, es eilt ganz dolle, wäre echt geil wenn ihr helfen könntet!

1. Will ich aus einem Delphi Programmheraus ein Winupdate startet
dieses wird mit Start/Ausführen "NDP1.1sp1-KB867460-X86.exe /q:" aufgerufen und muss auch so aus dem Delphi Prog gestartet werden

2. Will ich in Delphi auf die ausführung dieses Programmes warten

3. Ist es Möglich den Programmaufruf "NDP1.1sp1-KB867460-X86.exe /q:" als Parameter zu übergeben ? obwohl dort Leerzeichenvorhanden sind?
Vielen Dank für eure Hilfe !

[dfried]

Schau mal hier

[meisteralex]

thx, werds gleich mal proggen

hast du auch eine idee zu der parameterübergabe ?

[dfried]

Zitat:

Zitat von meisteralex

hast du auch eine idee zu der parameterübergabe ?

Schau dir mal die in dem Beispiel verwendet Funktion "CreateProcess" in der Hilfe mal an, dort gibt es auch noch diverse andere Paameter, evtl. musst du die "RunProcess" Funktion halt noch etwas umbasteln.

[meisteralex]

jo klappt alles soweit nur habe ich ein problem

so lange das programm läuft (er also auf die beendung des programmes wartet) hängt mein hauptprogramm
gibt es irgendne möglichkeit, da nen application.processmessages einzubauen, damit ich mein hauptprogramm weiterbenutzen kann?

[dfried]

Dann musst du das Starten des Programms am besten in einen separaten Thread verpacken, dann bleibt eine eigentliche Applikation "bedienbar".

[Klaus01]

Hallo,

ich benutze für solche Sachen immer diese Funktion:

Delphi-Quellcode:

{ WindowState is one of the SW_xxx constants.
  Look up ShowWindow in the API help for a list.}
function ExecAndWait(const Filename, Params: string;
                     WindowState: word): boolean;
{$IFDEF WIN32}
var
  SUInfo: TStartupInfo;
  ProcInfo: TProcessInformation;
  CmdLine: string;
begin
  { Enclose filename in quotes to take care of
    long filenames with spaces. }
  CmdLine := '"' + Filename + '" ' + Params;
  FillChar(SUInfo, SizeOf(SUInfo), #0);
  with SUInfo do begin
    cb := SizeOf(SUInfo);
    dwFlags := STARTF_USESHOWWINDOW;
    wShowWindow := WindowState;
  end;
  try
    Result := CreateProcess(NIL, PChar(CmdLine), NIL, NIL, FALSE,
                            CREATE_NEW_CONSOLE or
                            NORMAL_PRIORITY_CLASS, NIL,
                            PChar(ExtractFilePath(Filename)),
                            SUInfo, ProcInfo);
  except
    on E: Exception do
      begin
        Result:=false;
      end;
  end;

  { Wait for it to finish. }
  if Result then
    WaitForSingleObject(ProcInfo.hProcess, INFINITE);

{$ELSE}
var
  InstanceID : THandle;
  Buff: array[0..255] of char;
begin
  StrPCopy(Buff, Filename + ' ' + Params);
  InstanceID := WinExec(Buff, WindowState);
  if InstanceID < 32 then
  { a value less than 32 indicates an Exec error }
    Result := FALSE
  else begin
    Result := TRUE;
    repeat
      Application.ProcessMessages;
    until Application.Terminated or
          (GetModuleUsage(InstanceID) = 0);
  end;
{$ENDIF}
end;

Vielleicht kannst Du sie ja nach Deinen Anforderungen umbauen.

Grüße
Klaus

[meisteralex]

hmm was ist das denn fürn komisch quellcode ?

[dfried]

@meisteralex: Ich hab den Quelltext von Klausi01 mal noch etwas umgebaut (dann verstehst du Ihn wahrscheinlich besser) und auch schon ein "Application.Processmessages" mit reingemacht. Damit sollte es funktionieren!

Delphi-Quellcode:

{ WindowState is one of the SW_xxx constants.
  Look up ShowWindow in the API help for a list.}
function ExecAndWait(const Filename, Params: string;
                     WindowState: word): boolean;
var
  SUInfo: TStartupInfo;
  ProcInfo: TProcessInformation;
  CmdLine: string;
begin
  { Enclose filename in quotes to take care of
    long filenames with spaces. }
  CmdLine := '"' + Filename + '" ' + Params;
  FillChar(SUInfo, SizeOf(SUInfo), #0);
  with SUInfo do begin
    cb := SizeOf(SUInfo);
    dwFlags := STARTF_USESHOWWINDOW;
    wShowWindow := WindowState;
  end;
  try
    Result := CreateProcess(NIL, PChar(CmdLine), NIL, NIL, FALSE,
                            CREATE_NEW_CONSOLE or
                            NORMAL_PRIORITY_CLASS, NIL,
                            PChar(ExtractFilePath(Filename)),
                            SUInfo, ProcInfo);
  except
    on E: Exception do
      begin
        Result:=false;
      end;
  end;

  { Wait for it to finish. }
  if Result then begin
    Application.Processmessages;  // <-- diese Zeile hab ich eingefügt!!!
    WaitForSingleObject(ProcInfo.hProcess, INFINITE);
  end;

end;

[meisteralex]

friert trotzdem ein
das einfrieren liegt ja an
WaitForSingleObject
und ein application.processmessages davor bringt ja dann auch net viel

[dfried]

Also, dann doch nen eigenen Thread machen :-)

[Luckie]

Zitat:

Zitat von dfried

Also, dann doch nen eigenen Thread machen :-)

Das wäre am vernünftigsten. ;)

[meisteralex]

das geht mit der thread-klasse oder ? zumindest ging es so in c++
wie geht das in delphi ?und wie übergebe ich danndie rückmeldung ?

[Klaus01]

Nun, Du wolltest doch auf die Beendigung des auszuführenden Programms warten.

Zitat:

2. Will ich in Delphi auf die ausführung dieses Programmes warten

Das geht mit der Funktion. Davon, daß Du nebenläufig Dein
Hauptprogramm noch weiterarbeiten lassen willst hattest Du nichts geschrieben.

Grüße
Klaus

[dfried]

Zitat:

Zitat von meisteralex

das geht mit der thread-klasse oder ? zumindest ging es so in c++
wie geht das in delphi ?und wie übergebe ich danndie rückmeldung ?

Korrekt, hier findest du ein Tutorial zu Threads.

[meisteralex]

ach du scheiße, ne das ist mir jetzt zu aufwendig
gibts nicht ne prozedur die gucken kann ob die ProcessID noch am laufen ist ?

so nach dem motto

while prozezzidnochamlaufen(ProcID) do apllications.processmessages();

[Klaus01]

Zitat:

while prozezzidnochamlaufen(ProcID) do apllications.processmessages();

Wenn Du das so machen willst, dann "hängt" Dein Programm in der while Schleife, dann
kannst Du auch gleich waitforSingleObject nehmen.

Was Dir vielleicht entgegen kommen würde, wäre wenn Du in gewissen zeitlichen Abständen (TTimer) nachschaust
ob die ProcessID (ObjectID,handle) noch da ist oder schon beendet wurde.

Oder halt doch Threads verwenden.

Grüße
Klaus

[meisteralex]

selbst wenn ich die while schleife hab , sorgt ja das regelmäßige application.processmessages dafür das anstehende sachen bearbetet werden -> das hab ich ja schon getestet. ich brauch nur noch den code um zu gucken ob das programm noch da ist

[Klaus01]

Unit system

GetExitCodeProcess(ProcInfo.hProcess,ExitCode);

siehe auch Delphi Hilfe.

Grüße
Klaus