Executing External Programs/de

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ italiano (it) │ 日本語 (ja) │ Nederlands (nl) │ polski (pl) │ português (pt) │ русский (ru) │ slovenčina (sk) │ 中文（中国大陆）‎ (zh_CN) │

Einleitung

Es gibt verschiedene Wege, ein externes Programm auszuführen, aber ich will mich hier auf einen konzentrieren: TProcess.

Wenn sie bereits ShellExecute und/oder WinExec in Delphi verwenden, dann können sie damit beginnen, TProcess als Alternative in FPC/Lazarus zu verwenden (dies ist auch gültig, wenn sie Lazarus unter Linux starten, weil TProcess cross-platform ist).

Notiz: FPC/Lazarus bietet Unterstützung für ShellExecute und/oder WinExec, aber diese Unterstützung gibt es nur unter Win32. Wenn ihr Programm cross-platform sein soll, dann ist die Verwendung von TProcess der beste Weg!

SysUtils.ExecuteProcess

Wenn Sie keine Pipes oder sonstige Kontrollmechanismen benötigen, kann das Ausführen externer Programme sehr einfach über folgenden Befehl erreicht werden:

SysUtils.ExecuteProcess('/full/path/to/binary',['arg1','arg2']);

TProcess

Man kann TProcess benutzen, um externe Programme zu starten. Vorteile von TProcess sind

• Plattform unabhängig
• Es besteht die Möglichkeit, von stdout zu lesen und auf stdin zu schreiben.

Anmerkung: TProcess ist kein Terminal bzw. keine Shell! Weder können Scripte direkt ausgeführt werden, noch kann die Ausgabe mit Operatoren wie "|", ">", "<", "&" etc. umgeleitet werden. Es ist möglich, die gleichen Ergebnisse mit TProcess und FreePascal zu erziehen. Ein paar Beispiele finden Sie weiter unten.

Ein einfaches Beispiel

<delphi>

// Dies ist ein Demoprogramm, das zeigt, wie man ein
// externes Programm startet.
program launchprogram;

// Hier binden wir Dateien ein, die hilfreiche Funktionen
// und Prozeduren haben, die wir benötigen.
uses 
  Classes, SysUtils, Process;

// Dies definiert die Variable "AProcess" als eine Variable 
// vom Typ "TProcess"
var 
  AProcess: TProcess;

// Hier beginnt der Befehlstext:
begin
  // Nun erstellen wir das Objekt TProcess und
  // weisen es der Variable AProcess zu.
  AProcess := TProcess.Create(nil);

  // Lassen sie uns den FreePascal Compiler verwenden.
  // Dazu müssen wir AProcess den Komandozeilenbefel
  // übergeben:
  AProcess.CommandLine := 'ppc386 -h';

  // Während das externe Programm läuft, soll unser
  // Programm natürlich nicht weiterlaufen.
  // Dies regeln wir mit folgender Bedingung: 
  AProcess.Options := AProcess.Options + [poWaitOnExit];

  // Nun muss AProcess noch ausgeführt werden...
  AProcess.Execute;

  // Wegen der oben gesetzter Bedingung wird dieser
  // Codeabschnitt erst erreicht, wenn ppc386 beendet
  // ist:
  AProcess.Free;   
end.

</delphi>

Das war's. Sie haben gerade gelernt, wie man in Ihrem Programm ein externes Programm aufruft.

Ein verbessertes Beispiel

Das ist nett, aber wie lese ich den Output von einem Programm, das ich laufen habe?

Lassen sie uns unser Beispiel ein wenig erweitern und einfach das tun:

<delphi>

// Dies ist ein Demoprogramm, dass zeigt, wie man ein externes
// Programm startet und dessen Outout einliest.
program launchprogram;

// Hier binden wir Dateien ein, die hilfreiche Funktionen
// und Prozeduren haben, die wir benötigen.
uses 
  Classes, SysUtils, Process;

// Dies definiert die Variable "AProcess" als eine 
// Variable vom Typ "TProcess"
// Jetzt fügen wir auch eine TStringList hinzu, um die Ausgabe
// des Programmes zu speichern

var 
  AProcess: TProcess;
  AStringList: TStringList;

begin
  // Jetzt erzeugen wir das TProcess Objekt und
  // ordnen es der Variablen AProcess zu.
  AProcess := TProcess.Create(nil);

  // Erzeugen des TStringList Objekts.
  AStringList := TStringList.Create;

  // Gibt an, welcher Befehl vom Prozess ausgeführt werden soll
  // Lassen sie uns den FreePascal Compiler verwenden
  AProcess.CommandLine := 'ppc386 -h';

  // Wir definieren eine Option, wie das Programm
  // ausgeführt werden soll. Dies stellt sicher, dass
  // unser Programm nicht vor Beendigung des aufgerufenen
  // Programmes fortgesetzt wird. Außerdem geben wir an,
  // dass wir die Ausgabe lesen wollen
  AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];

  // Startet den Prozess, nachdem die Parameter entsprechend
  // gesetzt sind
  AProcess.Execute;
  
  // Folgendes wird erst nach Beendigung von ppc386 ausgeführt

  // Die Ausgabe wird nun in die Stringliste gelesen
  AStringList.LoadFromStream(AProcess.Output);
  
  // Speichert den output in eine Datei.
  AStringList.SaveToFile('output.txt');

  // Nun da die Datei gespeichert ist können wir 
  // TStringList und TProcess freigeben.
  AStringList.Free;
  AProcess.Free;   
end.

</delphi>

Einlesen eines großen Outputs

Im vorherigen Beispiel haben wir gewartet, bis das Programm beendet wurde. Dann haben wir gelesen, was das Programm in seinen output geschrieben hatte. Aber angenomme, das Programm schreibt eine Menge Daten in den output, wird die Pipe voll und das Programm angehalten, weil es wartet, bis die Pipe geleert wird. Aber das aufrufende Programm liest nicht aus der pipe, bis das aufgerufene Programm beendet wurde. Ein dead lock tritt auf.

Das folgende Beispiel benutzt daher nicht poWaitOnExit, sondern liest den output, während das Programm immer noch läuft. Der output wird in einem TMemoryStream gespeichert, der später verwendet werden kann, um den output in eine TStringList zu lesen.

<delphi>

program procoutlarge;
{
    Copyright (c) 2004 by Marc Weustink

    This example is creeated in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
}

uses
  Classes, Process, SysUtils;

const
  READ_BYTES = 2048;
  
var
  S: TStringList;
  M: TMemoryStream;
  P: TProcess;
  n: LongInt;
  BytesRead: LongInt;

begin
  // Wir können poWaitOnExit hier nicht nutzen, weil wir
  // die Größe des Outputs nicht kennen. In Linux ist die
  // Größe der Pipe 2kB. Wenn die Ausgabe größer ist, 
  // müsse die Daten zwischenzeitlich ausgelesen werden.
  // Dies ist nicht möglich, wenn auf das Ende gewartet wird
  // und ein Deadlock auftritt.
  //
  // Ein temporärer Memorystream wird verwendet, um den output zu puffern.
  
  M := TMemoryStream.Create;
  BytesRead := 0;

  P := TProcess.Create(nil);
  P.CommandLine := 'ppc386 -va bogus.pp';
  P.Options := [poUsePipes];
  WriteLn('-- executing --');
  P.Execute;
  while P.Running do
  begin          
    // stellt sicher, dass wir Platz haben
    M.SetSize(BytesRead + READ_BYTES);
    
    // versuche, es zu lesen
    n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
    if n > 0 
    then begin
      Inc(BytesRead, n);
      Write('.')
    end
    else begin     
      // keine Daten, warte 100 ms
      Sleep(100); 
    end;
  end;
  // lese den letzten Teil
  repeat
    // stellt sicher, dass wir Platz haben
    M.SetSize(BytesRead + READ_BYTES);
    // versuche es zu lesen
    n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
    if n > 0 
    then begin
      Inc(BytesRead, n);
      Write('.');
    end;
  until n <= 0;
  if BytesRead > 0 then WriteLn;
  M.SetSize(BytesRead); 
  WriteLn('-- executed --');
  
  S := TStringList.Create;
  S.LoadFromStream(M);
  WriteLn('-- linecount = ', S.Count, ' --');
  for n := 0 to S.Count - 1 do
  begin
    WriteLn('| ', S[n]);
  end;
  WriteLn('-- end --');
  S.Free;
  P.Free;
  M.Free;
end.

</delphi>

Verwendung von input und output eines TProcess

Siehe processdemo Beispiel im Lazarus-CCR SVN.

Hinweise für die Verwendung von TProcess

Wenn sie ein cross-platform Programm erstellen, können sie commandline unter Verwendung der Direktiven "{$IFDEF}s" und "{$ENDIF}s" entsprechend des OS ändern.

Beispiel:

{...}
  AProcess:TProcess.Create(nil)
  {$IFDEF WIN32} 
  AProcess.CommandLine := 'calc.exe'; //Windows Rechner
  {$ENDIF}
  {$IFDEF LINUX}
  AProcess.CommandLine := 'kcalc'; //KDE Rechner
  {$ENDIF}
  AProcess.Execute; //alternativ können sie AProcess.Active:=True verwenden
{...}

Beispiel von "talking" mit dem aspell Prozess

Innerhalb des pasdoc Quellcodes können sie zwei Units finden, die die Rechtschreibung prüfen, in dem sie mit dem laufenden aspell-Prozess durch Pipes kommuniziert:

• PasDoc_ProcessLineTalk.pas unit implementiert die TProcessLineTalk Klasse, einen Nachfahren von TProcess, der einfach benutzt werden kann, um eine "Zeilenweise" Kommunikation mit einem laufenden Prozess zu ermöglichen.

• PasDoc_Aspell.pas units implementiert die TAspellProcess Klasse, welche die Rechtschreibprüfung ausführt, in dem es den darunter liegenden Prozess von TProcessLineTalk nutzt, um aspell auszuführen und mit dem laufenden Prozess zu kommunizieren.

Beide Units sind ziemlich unabhängig vom Rest der pasdoc Quellen, so dass sie als praktische Demo für die Nutzung von TProcess dienen können.