Puis-je accéder à la chaîne renvoyée par une commande Delphi CreateProcess?

Question

J'utilise la fonction Win32 CreateProcess pour effectuer un appel à un exécutable externe. L'exécutable renvoie une chaîne.

Existe-t-il un moyen de capturer et d'interroger la chaîne renvoyée après avoir appelé l'exécutable? À défaut, il se peut que je doive écrire la chaîne dans un fichier de l'exécutable et la lire dans le programme appelant une fois l'appel terminé. Cela semble nul cependant.

Answer 1

La bibliothèque de code Jedi contient la fonction CreateDOSProcessRedirected qui exécute un processus et fournit le fichier d'entrée et de sortie. Vous pouvez insérer l'entrée éventuelle (le cas échéant) dans le fichier d'entrée et lire la sortie du processus (le cas échéant) à partir du fichier de sortie (une fois le processus terminé).

C’est ainsi que cela est implémenté dans la JCL :

function CreateDOSProcessRedirected(const CommandLine, InputFile, OutputFile: string): Boolean;
var
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
  SecAtrrs: TSecurityAttributes;
  hInputFile, hOutputFile: THandle;
begin
  Result := False;
  hInputFile := CreateFile(PChar(InputFile), GENERIC_READ, FILE_SHARE_READ,
    CreateInheritable(SecAtrrs), OPEN_EXISTING, FILE_ATTRIBUTE_TEMPORARY, 0);
  if hInputFile <> INVALID_HANDLE_VALUE then
  begin
    hOutputFile := CreateFile(PChar(OutPutFile), GENERIC_READ or GENERIC_WRITE,
      FILE_SHARE_READ, CreateInheritable(SecAtrrs), CREATE_ALWAYS,
      FILE_ATTRIBUTE_TEMPORARY, 0);
    if hOutputFile <> INVALID_HANDLE_VALUE then
    begin
      FillChar(StartupInfo, SizeOf(StartupInfo), #0);
      StartupInfo.cb := SizeOf(StartupInfo);
      StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
      StartupInfo.wShowWindow := SW_HIDE;
      StartupInfo.hStdOutput := hOutputFile;
      StartupInfo.hStdInput := hInputFile;
      Result := CreateProcess(nil, PChar(CommandLine), nil, nil, True,
        CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo,
        ProcessInfo);
      if Result then
      begin
        WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
        CloseHandle(ProcessInfo.hProcess);
        CloseHandle(ProcessInfo.hThread);
      end;
      CloseHandle(hOutputFile);
    end;
    CloseHandle(hInputFile);
  end;
end;

Answer 2

En supposant que vous souhaitiez capturer ce que le fichier exe écrit sur la sortie standard, vous pouvez commencer avec

yourprog.exe > results.txt

Ceci écrira la sortie dans results.txt , que vous pourrez ensuite lire et évaluer.

Vous pouvez également essayer la méthode décrite dans ce fil : Créer un canal pour la sortie de votre processus généré et lisez-le. Le numéro 7 a un exemple de source sur la façon d’utiliser les fonctions WinApi pertinentes en C ++, qui devrait facilement se traduire en Delphi.

Answer 3

Comment l'exécutable renvoie-t-il une chaîne ? Tout ce que je sais qu'un exécutable peut renvoyer est simplement un nombre, le code de sortie.

Answer 4

Vous pouvez utiliser la mémoire partagée pour communiquer entre les deux applications.

Vous pouvez utiliser la fonction Win32 CreateFileMapping et éventuellement utiliser un mutex pour synchroniser les appels vers le fichier mappé en mémoire.

Le code suivant crée le fichier.

var
  fMapping : THandle;
  pMapData : Pointer;

fMapping := CreateFileMapping($FFFFFFFF, nil, PAGE_READWRITE,
             0, MAPFILESIZE, pchar('MAP NAME GOES HERE'));

PMapData := MapViewOfFile(fMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);

le code suivant ferme le mapfile

if PMapData <> nil then
  UnMapViewOfFile(PMapData);
if fMapping <> 0 then
  CloseHandle(fMapping);