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;

					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.