Function StartProcess(FName,Arguments :String):Integer;
 // Nécessite l'ajout de l'unité System.Diagnostics dans la clause uses.
var MonProcessus : System.Diagnostics.Process ;
begin
  If FName<>'' then
   begin
      // Instance de la classe Process
      MonProcessus := System.Diagnostics.Process.Create;
      With MonProcessus do
      begin
        // Nom de l'executable à lancer
        StartInfo.FileName:=FName;
        
        // Arguments à passer à l'exécutable à lancer
        StartInfo.Arguments:=Arguments;
        
        // Démarrage du processus
        Start;
        
         // Récupére l'ID unique du process
        Result:=ID;
        
        // On libère les ressources dont on n'a plus besoin.
        Close; // Attention Close ne met pas fin au processus.
      end;
    end
   else Result:= -1;
end;

var ProcessID : Integer;
begin
 ProcessID:=StartProcess('Notepad.exe','C:\Windows\System.ini');
 ...

  ...
      With MonProcessus do
      begin
        // Nom de l'executable à lancer
        StartInfo.FileName:=FName;
        // Arguments à passer à l'exécutable à lancer
        StartInfo.Arguments:=Arguments;

        // La propriété EnableRaisingEvents indique si le composant doit être averti en cas d'arrêt
        // d'un processus par le système d'exploitation.
        // Elle est utilisée lors du traitement asynchrone pour avertir votre application qu'un processus
        // n'est plus exécuté.
        EnableRaisingEvents:=True;

       // Renseigne le délégué de fin de process
       Include(Exited ,@FinProcess);

        // Démarrage du processus
  ...

procedure FinProcess(Sender: System.Object; AArgs: System.EventArgs);
 // Procédure appelée lors de la fin d'exécution d'un programme externe
begin
 Writeln(' Code de fin du processus : '+(Sender as System.Diagnostics.Process).ExitCode.ToString);
 Writeln(' Appuyez sur une touche pour terminer.');
end;

Procedure KillProcess(ProcessID : Integer);
 // Nécessite l'ajout de l'unité de System.Diagnostics dans la clause uses.
var MonProcessus : System.Diagnostics.Process ;

begin
  // Voir "Comment lancer un processus ?"
 Readln;
 try
   // Récupére une instance d'un Processus à partir d'un ID
   MonProcessus:=System.Diagnostics.Process.GetProcessById(ProcessID);

   // Obtient le Handle de la fenêtre principale
   // Pour terminer le processus
   if MonProcessus.MainWindowHandle<>0
     // Pour un programme fenêtré
    then MonProcessus.CloseMainWindow
     // Pour un programme console, c'est la seule possibilité.
    else MonProcessus.Kill;
          // On libère les ressources dont on n'a plus besoin.
   MonProcessus.Close;
 except
  on System.ArgumentException do
   Writeln('Erreur le processus '+IntToStr(ProcessID)+' n''existe pas !');
 end;
end;

 < ! [CDATA[
program Batch;
{$APPTYPE CONSOLE}
// Pilote un prg externe

uses
  System.Diagnostics,
  System.IO; //StreamWriter

var MyProcess : System.Diagnostics.Process ;
    ProcessInformation : System.Diagnostics.ProcessStartInfo;
    Chaine: String;

begin
    ProcessInformation:=System.Diagnostics.ProcessStartInfo.Create;
    With ProcessInformation do
    begin
       // On désactive le shell
       // permet de rediriger les flux d'entrée, de sortie et d'erreur.
       // Dans ce cas 'WorkingDirectory' n'est pas utilisé
      UseShellExecute := False;

       // On redirige la sortie standard du programme externe
       // Permet d'écrire à un emplacement autre que le flux de sortie standard (généralement l'écran du moniteur).
       // Utilisé pour écrire des données dans un fichier, par exemple.
      RedirectStandardOutput := True;
       // On redirige l'entrée standard du programme externe

       //permet de lire à partir d'une source autre que le flux d'entrée standard (généralement le clavier).
       //Utilisé pour lire des données dans un fichier, par exemple.
      RedirectStandardInput := True;

      // si UseShellExecute := False : On définit le programme à exécuter
      FileName := 'C:\Windows\System32\Debug.exe';
    end;

  MyProcess := System.Diagnostics.Process.Create;

  With MyProcess do
   begin
    StartInfo:=ProcessInformation;
     // Exécute le programme externe
    Start;
(*
  Prg principale         prg externe
   --------             ---------
   |      |IN        IN |       |
   |      |<--\    /--> |       |
   |      |    \  /     |       |
   |      |     \/      |       |
   |      |OUT  /\  OUT |       |
   |      |--> /  \ <-- |       |
   --------             ---------

   Dans le prg principale :
    on écrit vers OUT
    on lit à partir de IN
*)

     //Redirige l'entrée et la sortie standard avec ceux du prg externe
      // Connecte la sortie standard ( CON /écran) sur l'entrée du programme externe
      // On peut donc, via Writeline, entrer une saisie destinée au programme externe
    System.Console.SetOut(MyProcess.StandardInput);

      // Connecte l'entrée standard ( CON /Clavier ) sur la sortie du programme externe
      // On peut donc, via Readline, lire un résultat provenant du programme externe
    System.Console.SetIn(MyProcess.StandardOutput);

    Close;
   end;
// Envoie 3 commande au prg externe, ici DEBUG,  
// ? : demande d'afficher l'aide
// D : demande un dump (128 octets)
// Q : Quitte et termine l'application externe
   System.Console.Out.Writeline('?'+#10#13+'D'+#10#13+'Q');

// Lit le résultat affiché par DEBUG
    // Lecture en une seule fois
   //Chaine:=System.Console.In.ReadToEnd;

   // Lecture ligne par ligne
   Chaine:=''; // Nécessaire sinon la variable 'Chaîne' n'est pas instancié !

   While Assigned(Chaine) do
    begin
     Chaine:=System.Console.In.ReadLine;
      // Ecrit sur la sortie standard TextOutput
      // Si on remplace par Console.WriteLine(Chaine) le comportement est différent !
     WriteLn(chaine); // Est égale à TextOutput.Writeln. Cf IL-Dasm
    end;
  //Restaure les valeurs par défaut
  //Pas nécessaire de mémoriser les valeurs, on récrée un objet.
  // Sous Delphi c'est redondant cf. TextOutput...
 System.Console.SetOut(StreamWriter.Create(System.Console.OpenStandardOutput));
 System.Console.SetIn(StreamReader.Create(System.Console.OpenStandardInput));

 readln;
end.

 type upper.dpr|upper.exe

program upper;
{$APPTYPE CONSOLE}
// Redirection de type 'PIPE', comportement similaire au programme FIND.EXE ou SORT.EXE
// Renvoie une chaîne reçue en entrée (input) en majuscule sur la sortie (output)

Var Chaine: String;

Begin
  { TextInput et TextOutPut sont construit autour de la classe :
      Text = class
        Mode: Word;
        Flags: Word;
        Factory: ITextDeviceFactory;
        Reader: System.IO.TextReader;
        Writer: System.IO.TextWriter;
        Filename: string;
        ...
  }
 While not(Eof) Do
  Begin
    // TextInput   { Entrée standard }
      // TextInput.Intput=Text
      // TextInput.Input.Reader := System.Console.In;
   Readln(TextInput.Input,Chaine);  // Lit sur l'entrée standard

    // TextOutput  { Sortie standard}
      // TextInput.Output=Text
      // TextInput.Output.Writer := System.Console.Out;
   Writeln(TextOutput.OutPut,chaine.ToUpper); // Ecrit sur la sortie standard

    // Erreur standard :
      //  TextErrOutput.ErrOutput := Text
      //  TextErrOutput.ErrOutput.Writer := System.Console.Error;
  end;
end.

program upper2;
{$APPTYPE CONSOLE}
// Redirection de type 'PIPE', comportement similaire au programme FIND.EXE ou SORT.EXE
// Renvoie une chaîne reçue en entrée (input) en majuscule sur la sortie (output)

 Var Chaine: String;

Begin
 While not(Eof) Do
  Begin
   Readln(Chaine);  // Lit sur l'entrée standard
   Writeln(chaine.ToUpper); // Ecrit sur la sortie standard
  end;
end.

procedure TWinForm.RedirectStdOutput;
var proc : System.Diagnostics.Process ;
    output : String ;
begin
    proc:=System.Diagnostics.Process.Create;
     // On désactive le shell
    proc.StartInfo.UseShellExecute:=false;
     // On redirige la sortie standard
    proc.StartInfo.RedirectStandardOutput:=true;
     // On définit la commande 
    proc.StartInfo.FileName:='EditeurFAQ.exe';
     // Démarrage de la commande
    proc.Start;
     // Lecture de la sortie de la commande
    output:=proc.StandardOutput.ReadToEnd;
    Console.WriteLine(output);
     // Attente de la fin de la commande
    proc.WaitForExit;
     // Libération des ressources
    proc.Close;
end ;

uses
  SysUtils,
  System.Diagnostics;

var AllProcess : array of System.Diagnostics.Process ;
    prc : System.Diagnostics.Process;

begin
  // Pour tous les processus en cours sur l'ordinateur local
 AllProcess:= Process.GetProcesses ;
 For prc in AllProcess do
  Writeln(Prc.ProcessName);

 Writeln;

  // Pour tous les processus notepad en cours sur l'ordinateur local
 AllProcess := Process.GetProcessesByName('svchost') ;
 If length(AllProcess)>0 then
  For prc in AllProcess do
   With prc do
    Writeln(ProcessName+'. Mémoire allouée:'+PrivateMemorySize.ToString);
end.