uses System.Diagnostics,
					SysUtils;

					var VersionApplication : FileVersionInfo ;
					MaVersion : String ;
					Begin
					// Récupére le nom de l'application via la ligne de commande
					// L'argument 0 de la ligne de commande est le nom de l'application en cours d'exécution
					VersionApplication := FileVersionInfo.GetVersionInfo(Paramstr(0));

					// Construction du numéro de version à partir des différentes parties le constituant
					// L'utilisation de la fonction Format nécessite l'ajout de l'unité SysUtils dans la clause uses.
					with VersionApplication do
					MaVersion:=Format('%d.%d.%d.%d', [FileMajorPart,
					FileMinorPart,
					FileBuildPart,
					FilePrivatePart]);
					Writeln('MaVersion '+MaVersion);

					// Accés direct au numéro construit 1.2.3.4
					Writeln('Information de version du fichier '+VersionApplication.Fileversion);
					Readln;
					end;

					ver := FileVersionInfo.GetVersionInfo(Environment.GetCommandLineArgs('C:\WINDOWS\notepad.exe');

					// Version Framework
					var VerFram : Version ;
					begin
					VerFram := Environment.Version;
					Console.WriteLine('Version Framework = {0}', VerFram);
					end;

					// Version du système d'exploitation
					var OSver : Version ;

					begin
					OSver := Environment.OSVersion;
					Console.WriteLine('Version OS = {0}', OSver);
					end;

					var Exepath : String ;
					Exedir : String ;
					begin
					// Chemin de l'exécutable
					// Pour les WinForms, on peut aussi utiliser Application.ExecutablePath
					Exepath := Environment.GetCommandLineArgs()[0];

					// Répertoire de l'exécutable
					Exedir := exepath.Substring(0, exepath.LastIndexOf('\'));

					// Répertoire courant
					Console.WriteLine('Le répertoire courant est : {0}', Environment.CurrentDirectory);

					// Répertoire système
					Console.WriteLine('Répertoire système = {0}', Environment.SystemDirectory);

					Console.WriteLine('Nom utilisateur = {0}', Environment.UserName);

					Console.WriteLine('Mémoire allouée au process en cours = {0} octets',
					Environment.WorkingSet.ToString);

					Console.WriteLine('La ligne de commande est : {0}', Environment.CommandLine);

					var arguments : Array of String ;
					i , j : Integer ;
					begin
					// Arguments de ligne de commande
					arguments := Environment.GetCommandLineArgs;
					j:= Length(arguments) ;
					for i := 0 to j-1 do
					Console.WriteLine('Arguments[{0}] = {1}', [i,arguments[i]]);
					end;

					var
					VarEnvironnement : IDictionary; // Ajout System.Collections
					Entrees          : DictionaryEntry;
					begin
					VarEnvironnement:= Environment.GetEnvironmentVariables;
					// Pour afficher une variable dont on connait le nom
					WriteLn('USERNAME = '+ VarEnvironnement['USERNAME'].ToString);
					// Pour lister toutes les variables
					For Entrees in VarEnvironnement do
					WriteLn(Entrees.Key.ToString+' = '+Entrees.Value.ToString);
					Readln;
					end;

					procedure PrintSpecFolder;
					type
					TSpecialFolderDynArray  = array of Environment.SpecialFolder;

					var Folders  : TSpecialFolderDynArray;
					i        : Integer;
					unFolder : Environment.SpecialFolder;

					begin
					// Répertoire spéciaux
					Console.WriteLine('Répertoire spéciaux');

					// Récupére un tableau contenant les noms des répertoires spéciaux
					Folders:= TSpecialFolderDynArray(Enum.GetValues(typeof(Environment.SpecialFolder)));

					For i:= 0 to Length(Folders)-1 do
					begin
					Console.WriteLine(Folders[i]);
					// Affiche le répertoire associé au nom de répertoire courant
					Console.WriteLine(Environment.GetFolderPath(Folders[i]));
					end;

					//----------------------------------------------------------------------------
					// exemples de manipulation sur les énumérations .NET
					//
					// Résulat identique mais en utilisant une variable intermédiaire
					For i:= 0 to Length(Folders)-1 do
					begin
					unFolder:=Folders[i];
					Console.WriteLine('{0} = {1}', [unFolder,Environment.GetFolderPath(unFolder)]);
					end;

					// Affiche directement le répertoire associé à un nom de répertoires spécial
					Console.WriteLine(Environment.SpecialFolder.MyMusic);

					// Recherche un élément par un nom de chaîne
					UnFolder:=System.Enum.Parse(TypeOf(Environment.SpecialFolder),'MyMusic') as Environment.SpecialFolder;
					// Boxing nécessaire avec l'affichage par Writeln
					WriteLn('Le nom est = '+Tobject(unFolder).ToString);

					// Pas de boxing ni de transtypage avec l'affichage par Console.Writeline
					Console.WriteLine(System.Enum.Parse(TypeOf(Environment.SpecialFolder),'MyMusic'));
					//----------------------------------------------------------------------------

					Readln;
					end;

					procedure PrintLogicalDrives ;
					// Uses : ajout de Borland.Vcl.Types pour TStringDynArray;
					var Drives : TStringDynArray;
					i      : Integer ;
					begin
					// Lecteurs logiques
					Console.WriteLine('Lecteurs logiques');
					drives := Environment.GetLogicalDrives;
					for i := 0 to Length(drives)-1 do
					Console.WriteLine(drives[i]);
					end;

					uses
					SysUtils,
					System.Threading;

					type
					TSingleInstanceApp=class
					private
					FMutex : Mutex;
					MutexOwned : Boolean;

					public
					Constructor Create(Nom : String);
					// Application déjà lancée ?
					Function IsRunning : Boolean;
					Destructor Destroy; override;

					end;
					{ TSingleInstanceApp}

					Constructor TSingleInstanceApp.Create(Nom : String);
					begin
					inherited Create;
					FMutex:=Mutex.Create(False, Nom);
					MutexOwned:=False;
					end;

					Function TSingleInstanceApp.IsRunning : Boolean;
					begin
					try
					// Acquisition du mutex.
					// Si MutexOwned vaut True, l'application acquiert le mutex car il est "libre"
					// sinon le mutex a déjà été acquis lors du lancement d'une instance précédente.
					MutexOwned:=FMutex.WaitOne(0, true);
					finally
					result:=Not MutexOwned;
					end;
					end;

					Destructor TSingleInstanceApp.Destroy;
					// Libération du mutex si il a été acquis
					Begin
					// Sécurise ce traitement ('thread-safe').
					Monitor.Enter(Self);
					Try
					if MutexOwned
					then FMutex.ReleaseMutex;
					inherited Destroy;

					Finally
					Monitor.Exit(Self);
					end;
					end;

					var
					MonApplication : TSingleInstanceApp;
					begin
					MonApplication:= TSingleInstanceApp.Create('{123456789 - ABCD - EFEG - XXXX}');
					if MonApplication.IsRunning
					then
					begin
					Writeln(ParamStr(0)+' est déjà en cours d''exécution, une seule instance est autorisée.');
					MonApplication.Free;
					Halt(1);
					end;
					Writeln('Pressez une touche pour continuer');
					Readln;
					MonApplication.Free;
					end.

					program random;
					{$APPTYPE CONSOLE}
					uses
					SysUtils,
					Types;

					var rnd : System.Random;
					d   : double;
					i,j : Integer;
					rndNumbers : TByteDynArray;

					begin
					// Pour générer toujours la même séquence,
					// on passe la même valeur au constructeur.
					// Random rnd = new Random(100);

					// Initialisation par défaut basée sur le temps.
					// La séquence est différente à chaque fois.
					rnd:=System.Random.Create;

					// Génération de 15 nombres aléatoires compris entre 0 et 255
					rndNumbers:=new(TByteDynArray,15);
					rnd.NextBytes(rndNumbers);
					for i:=0 to 14 do
					begin
					// On peut aussi faire un modulo pour n'obtenir que
					// des nombres entre 0 et 100 par exemples
					if (rndNumbers[i] > 100)
					then Writeln(Format('%5d est supérieure à 100',[rndNumbers[i]]))
					else Writeln(Format('%3d est inférieure à 100',[rndNumbers[i]]));
					end;
					Writeln;
					// Pour générer des nombres aléatoire de type Integer
					i:=rnd.Next;
					Writeln(i.ToString+#13#10);
					j:=rnd.Next(500, 1000); // j sera compris entre 500 et 1000
					Writeln(j.ToString+#13#10);

					// Pour générer des nombre aléatoire de type Double
					// d sera compris entre 0,0 et 1,0.
					// Il suffit de combiner cet appel à celui de Next()
					// pour avoir des doubles supérieurs à 1,0
					d:=rnd.NextDouble;
					Writeln(d.ToString);
					Readln;
					end.

					{$APPTYPE CONSOLE}

					uses
					SysUtils,
					System.Diagnostics;

					var prc : System.Diagnostics.Process;

					begin

					// Instance de la classe Process
					prc := System.Diagnostics.Process.Create;

					// Nom du fichier dont l'extension est connue du shell à ouvrir
					prc.StartInfo.FileName:='monfichier.txt';

					// Démarrage du processus.
					// Notepad, si il est associé aux fichiers .txt,
					// sera lancé et ouvrira le fichier monfichier.txt
					prc.Start ;

					// On libère les ressources dont on a plus besoin.
					prc.Close; // Attention Close ne met pas fin au processus.

					uses
					SysUtils;

					var i : Integer ;
					s : String ;
					begin
					// Conversion d'un entier vers une chaîne de caractères
					i:=10;
					s:=Convert.ToString(i);

					//Autres possibilités
					// Appel la méthode TObject.ToString
					s:=i.ToString;
					// Portable Win32 /.NET/, appel en interne de la méthode Convert.ToString
					S:=IntToStr(i);

					// Conversion d'une chaine vers un entier
					i:= Convert.ToInt32(s);

					//Autre possibilité
					// Portable Win32 /.NET, appel en interne de la méthode Borland.Vcl.Units.SysUtils.StrToInt
					i:= StrToInt(s);

					// Notez que si la conversion ne peut se faire, une exception est levée.
					// Ce serait le cas si S='Chaîne NonNumérique', cf. System.FormatException

					s := '35000';
					i := System.Int32.Parse(s);

					Function ConvertCtoF(CentValue: Integer): Integer; stdcall;
					Function ConvertFtoC(FahrValue: Integer): Integer; stdcall;

					[DllImport('Win32DLL.dll', CharSet = CharSet.Auto, EntryPoint = 'ConvertCtoF')]
					Function ConvertCtoF; external;
					[DllImport('Win32DLL.dll', CharSet = CharSet.Auto, EntryPoint = 'ConvertFtoC')]
					Function ConvertFtoC; external;

					Uses Borland.Vcl.Win32;

					type
					// Il n'est pas nécessaire d'utiliser l'attribut DllImport sur ce prototype.
					IWin32DLLInt = interface
					function ConvertCtoF(CentValue: Integer): Integer;
					function ConvertFtoC(FahrValue: Integer): Integer;
					end;

					var MyDLL      : String;        // Nom complet de la DLL
					MyWin32DLL : IWin32DLLInt; // Interface contenant les fonctions exportées et non managées
					begin
					MyDLL := ExtractFilePath(Application.ExeName) +'\mylib\Win32DLL.dll';

					// Appel à travers l'interface
					if not SysUtils.Supports(MyDLL, IWin32DLLInt, MyWin32DLL)
					then Writeln('Ne peut charger Win32DLL.dll') // Erreur
					else NewInt := MyWin32DLL.ConvertCtoF(100);  // Appel de la fonction de la DLL non-managée

					program FaqDLL;

					{$APPTYPE CONSOLE}

					uses
					Borland.Vcl.Win32,
					SysUtils;

					type
					// Il n'est pas nécessaire d'utiliser l'attribut DllImport sur ce prototype.
					IWin32DLLInt = interface
					function ConvertCtoF(CentValue: Integer): Integer;
					function ConvertFtoC(FahrValue: Integer): Integer;
					end;

					var MyDLL      : String;       // Nom complet de la DLL
					MyWin32DLL : IWin32DLLInt; // Interface contenant les fonctions exportées et non managées
					NewInt     : Integer;
					begin
					MyDLL := ExtractFilePath(Environment.GetCommandLineArgs[0]) +'\mylib\Win32DLL.dll';

					// Si la fonction Supports renvoie True, la DLL prend en charge toutes les fonctions nommées dans
					// la déclaration de l'interface, et vous savez donc que leur appel est sans danger.
					if not SysUtils.Supports(MyDLL, IWin32DLLInt, MyWin32DLL)
					then Writeln('Ne peut charger Win32DLL.dll') // Erreur
					else NewInt := MyWin32DLL.ConvertCtoF(100);  // Appel de la fonction de la DLL non-managée

					Readln;
					end.

					var monCaractere : char ;
					monCaractere := #0;

					uses System.Text.RegularExpressions ;

					function TWinForm.CheckIpAddr( ipAddress : String ) : Boolean ;
					var re : String ;
					begin
					re := '^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$' ;
					result := Regex.IsMatch( ipAddress,re);
					end;

					function CheckIpAddrNoRegex( ipAddress : String ) : Boolean;
					var ipPartList : array of String;
					ipPartNumber : byte;
					Resultat : Boolean;
					begin
					Resultat := True;

					if (ipAddress = nil) OR (ipAddress = '')
					then Resultat := False;

					ipPartList:=ipAddress.Split( ['.'] );
					if Length(ipPartList) <> 4
					then Resultat := False;

					try
					begin
					ipPartNumber := Convert.ToByte(ipPartList[0] );
					ipPartNumber := Convert.ToByte(ipPartList[1] );
					ipPartNumber := Convert.ToByte(ipPartList[2] );
					ipPartNumber := Convert.ToByte(ipPartList[3] );
					end ;
					Except
					on E : Exception do
					Resultat:=False;
					end;
					Result:=Resultat;
					end;