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(Environment.GetCommandLineArgs[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 de 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 monCaractère : char ;
monCaractère := #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 TWinForm.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 ;