Kommandozeilenprogramm ausführen und Ausgabe umleiten

[Shark99]

Ich habe folgenden Code in einer Batchdatei:

dc64cmd.exe -listmonitors >w:\temp\monitors.txt

Wie kann ich dc64cmd.exe mit Delphi starten und die Ausgabe in eine Datei umleiten?

Auf den ersten Blick sehe ich weder bei ShellExecute() noch bei CreateProcess() eine Möglichkeit die Ausgabe in eine Datei umzuleiten.

Danke im Voraus!

[DeddyH]

Einfach die Exe starten und die Parameter übergeben samt Dateiumleitung.
ShellExecute(0,'open','dc64cmd.exe','-listmonitors > w:\temp\monitors.txt',nil,SW_SHOW); [edit] Achso, Kommandozeilenprogramm. Du kannst es auch so versuchen:
ShellExecute(0,'open','cmd.exe','/c dc64cmd.exe -listmonitors > w:\temp\monitors.txt',nil,SW_SHOW); Ermitteln des Kommandointerpreters und Auswertung des Rückgabewertes habe ich alles weggelassen, das kannst Du ja noch implementieren [/edit]

[himitsu]

Das diese Umleitung via > ein Feature des CommandLine-Interpreters sein dürfte, wirst du hierfür auch diesen (z.B. die cmd.exe) ansprechen müssen.

Ansonsten könntest du über CreateProcess in der STARTUPINFO auch einen anderen StdOutput angeben, z.B. ein FileHandle oder eine Pipe.

[Florian Hämmerle]

http://www.swissdelphicenter.ch/de/showcode.php?id=990 zeigt wie du die Ausgabe der Konsole erhältst.

mfg Florian

[Teekeks]

Das ist dann aber doof wenn der Zwischenpuffer voll läuft. dann wartet das ausgeführte Programm darauf das dieser geleert wird, und das ausführende Programm wartet darauf das sich das Programm beendet, damit der Puffen geleert werden kann.
Ergo: Endloßschleife.

Besser ist das hier:

Delphi-Quellcode:

   
const
   READ_BYTES = 2048;

var proc:TProcess;
   S2: TStringList;
   M: TMemoryStream;
   n: LongInt;
   BytesRead: LongInt;
begin
   M := TMemoryStream.Create;
   BytesRead := 0;
   proc:=TProcess.create;
   proc.Options:=[poUsePipes];
   Proc.CommandLine :='WasAuchImmer.echse';
   Proc.Execute;
   while Proc.Running do
   begin
     // stellt sicher daß wir Platz haben
     M.SetSize(BytesRead + READ_BYTES);

     // versuche es zu lesen
     n := Proc.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
     if n > 0
     then begin
       Inc(BytesRead, n);
     end
     else begin
       // keine Daten, warte 100 ms
       Sleep(100);
     end;
   end;
   // lese den letzten Teil
   repeat
     // stellt sicher daß wir Platz haben
     M.SetSize(BytesRead + READ_BYTES);
     // versuche es zu lesen
     n := Proc.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
     if n > 0
     then begin
       Inc(BytesRead, n);
     end;
   until n <= 0;
   M.SetSize(BytesRead);

   S2 := TStringList.Create;
   S2.LoadFromStream(M);
//mache was mit dem Output...
   S2.Free;
   M.Free;
   proc.free;
end;

[Codehunter]

Ich fleddere mal diese Leiche und ergänze die Frage: Hat sich vielleicht in den letzten 8 Jahren, seit dieser Thread erstellt wurde, in der RTL etwas getan? So dass Delphi möglicherweise das Pipen von Konsolenausgaben von Haus aus mit wenig Code ermöglicht?

[himitsu]

Nicht, dass ich wüsste.

Ich glaub aber sowas wie DOSBox mal im GetIt gesehn zu haben.

[Uwe Raabe]

Zitat von himitsu:

Ich glaub aber sowas wie DOSBox mal im GetIt gesehn zu haben.

DOSCommand

[jziersch]

Ich habe diese Funktion eingesetzt um die Ausgabe von DCRaw in einen Stream umzuleiten.

Code:

function GetDosOutput(CommandLine: string; Params: string; AStream : TStream): Integer;
var
  SA: TSecurityAttributes;
  SI: TStartupInfo;
  PI: TProcessInformation;
  StdOutPipeRead, StdOutPipeWrite: THandle;
  WasOK: Boolean;
  Buffer: array[0..255] of AnsiChar;
  BytesRead: Cardinal;
  WorkDir, AParameter: string;
  Handle: Boolean;
begin
  Result := 0;
  with SA do begin
    nLength := SizeOf(SA);
    bInheritHandle := True;
    lpSecurityDescriptor := nil;
  end;
  CreatePipe(StdOutPipeRead, StdOutPipeWrite, @SA, 0);
  try
    with SI do
    begin
      FillChar(SI, SizeOf(SI), 0);
      cb := SizeOf(SI);
      dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
      wShowWindow := SW_HIDE;
      hStdInput := GetStdHandle(STD_INPUT_HANDLE); // don't redirect stdin
      hStdOutput := StdOutPipeWrite;
      hStdError := StdOutPipeWrite;
    end;
    WorkDir := 'C:\';
    AParameter := Format('"%s" %s', [CommandLine, TrimRight(Params)]);

    Handle := CreateProcess(nil, PChar({'cmd.exe /C ' + }AParameter),
                            nil, nil, True, 0, nil,
                            PChar(WorkDir), SI, PI);
    CloseHandle(StdOutPipeWrite);
    if Handle then
      try
        repeat
          WasOK := ReadFile(StdOutPipeRead, Buffer, 255, BytesRead, nil);
          if BytesRead > 0 then
          begin
            AStream.Write(Buffer[0],BytesRead);
            Result := Result + BytesRead;
          end;
        until not WasOK or (BytesRead = 0);
        WaitForSingleObject(PI.hProcess, INFINITE);
      finally
        CloseHandle(PI.hThread);
        CloseHandle(PI.hProcess);
      end;
  finally
    CloseHandle(StdOutPipeRead);
  end;
end;

vgl: http://stackoverflow.com/questions/9...o-a-delphi-app

Grüsse,
Julian

[Benmik]

Ich vermute mal, das hier ist identisch mit dem bereits Geposteten, aber es ist eine Lösung, die ich bereits erfolgreich angewendet habe.
Wundert mich, dass sich Uwe Raabe so zurückhält, hat er sich doch hier bereits engagiert.