💎 Delphi (RAD Studio) – Le Guide Ultime

Delphi est un IDE (Integrated Development Environment) et un langage (Object Pascal). Il a été créé par Borland en 1995 et est maintenant géré par Embarcadero (sous le nom de RAD Studio).

C'est le "père" du RAD (Rapid Application Development). Sa philosophie est de permettre de construire des applications (surtout de bureau Windows) incroyablement vite grâce au "drag-and-drop" de composants visuels.

Caractéristiques Clés

• IDE Visuel : On "dessine" l'interface en déposant des boutons, grilles, etc.
• Langage Object Pascal : Un langage structuré, fortement typé, basé sur Pascal, mais 100% orienté objet.
• Compilation Native : Sa "killer feature". Contrairement à Java ou .NET (à l'époque), Delphi compile en code machine natif (x86/x64). Pas de VM, pas de JIT. Les .exe sont ultra-rapides et autonomes.
• VCL (Visual Component Library) : La bibliothèque de composants pour Windows. (Voir 2.1).
• FMX (FireMonkey) : Le "dérivé" moderne pour le cross-platform (Windows, macOS, iOS, Android, Linux). (Voir 2.2).

Le cœur de Delphi est le RAD et son "Two-Way Tooling" (outillage bi-directionnel). C'est ce qui le sépare de (par exemple) Visual Basic classique.

Two-Way Tooling (Code <-> Visuel)

Le code et le designer sont *synchronisés*.

1. Visuel -> Code : Vous glissez un TButton sur la Form (visuel). L'IDE ajoute automatiquement la ligne Button1: TButton; à votre classe (code).
2. Code -> Visuel : Vous écrivez Button2: TButton; dans le code. Le composant *apparaît* sur le Form Designer.

.pas vs .dfm (Code vs Form)

Chaque "Form" (fenêtre) est composée de deux fichiers :

# Contenu (simplifié) de Unit1.dfm
object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Ma Fenêtre'
  ClientHeight = 300
  ClientWidth = 400
  object Button1: TButton
    Left = 40
    Top = 50
    Width = 75
    Height = 25
    Caption = 'Cliquez ici'
    OnClick = Button1Click
  end
end

Le langage de Delphi est Object Pascal. Il est fortement typé, non-sensible à la casse (MaVar est égal à mavar), et utilise begin...end; pour les blocs.

Structure d'un Fichier (unit)

Chaque fichier (.pas) est une "unité" (unit) qui a deux parties : interface et implementation.

unit MyUnit;

// --- 1. INTERFACE ---
// (Partie publique, "Header" C++)
// Ce qui est visible par les autres units.
interface

uses
  System.Classes, System.SysUtils; // Imports

type
  TMonType = (mtUn, mtDeux, mtTrois); // Enum
  
  TMaClasse = class(TObject)
  private
    FNom: string;
  public
    procedure FaireQuelqueChose;
  end;

// --- 2. IMPLEMENTATION ---
// (Partie privée, "cpp")
// Le code des méthodes.
implementation

procedure TMaClasse.FaireQuelqueChose;
begin
  ShowMessage('Hello'); // Fonction globale (VCL)
end;

end. // (Fin de l'unité)

Syntaxe de Base

// --- Variables ---
var
  MonEntier: Integer;
  MonTexte: string;
  MaListe: TStringList;

// --- Assignation ---
MonEntier := 10; // (Utilise ':=')
MonTexte := 'Bonjour';

// --- Contrôle (if/else) ---
if (MonEntier > 5) and (MonTexte = 'Bonjour') then
begin
  ShowMessage('Test 1 OK')
end
else
begin
  ShowMessage('Test 2 KO');
end; // (Note: le ';' est un SÉPARATEUR)

// --- Boucle For ---
for MonEntier := 1 to 10 do
begin
  // ...
end;

La POO en Object Pascal est très puissante. Toutes les classes héritent implicitement de TObject.

Classe, Constructeur & Destructeur

La gestion de la mémoire est *manuelle* (comme en C++). On doit appeler .Free (le destructeur) sur les objets qu'on crée.

type
  TPersonne = class(TObject)
  private
    FNom: string; // Convention: 'F' (Field) pour les champs privés
    FAge: Integer;
  public
    constructor Create(ANom: string; AAge: Integer); // 'A' = Argument
    destructor Destroy; override;
    
    procedure FeterAnniversaire;
  end;

// ...
constructor TPersonne.Create(ANom: string; AAge: Integer);
begin
  inherited Create; // Appelle le constructeur de TObject
  FNom := ANom;
  FAge := AAge;
end;

destructor TPersonne.Destroy;
begin
  // (Logique de nettoyage si nécessaire)
  inherited Destroy; // Appelle le destructeur parent
end;

procedure TPersonne.FeterAnniversaire;
begin
  FAge := FAge + 1;
end;

La "Killer Feature" : property (Getters/Setters)

Delphi a inventé le concept de "property" (repris par C#). C'est une méthode qui *ressemble* à une variable.

type
  TPersonne = class(TObject)
  private
    FNom: string;
    function GetNom: string;
    procedure SetNom(const Value: string);
  public
    constructor Create;
    
    // 1. Déclaration de la "Propriété"
    // (Elle "pointe" vers les méthodes getter/setter)
    property Nom: string read GetNom write SetNom;
  end;
  
// ...
function TPersonne.GetNom: string;
begin
  Result := FNom; // 'Result' est la variable de retour
end;

procedure TPersonne.SetNom(const Value: string);
begin
  if Value = '' then
    raise Exception.Create('Le nom ne peut pas être vide');
  FNom := Value;
end;

// --- Utilisation ---
var
  P: TPersonne;
begin
  P := TPersonne.Create;
  P.Nom := 'Alice'; // Appelle SetNom
  ShowMessage(P.Nom); // Appelle GetNom
  P.Free;
end;

L'IDE (maintenant appelé "RAD Studio") est le cœur de l'expérience Delphi. C'est là que la magie du "RAD" opère.

Les 4 Fenêtres Clés

Data Explorer

Une fonctionnalité clé est la connexion aux données *en design-time*. Vous pouvez glisser un TFDConnection, le connecter à votre BDD (SQL Server, etc.) *dans l'IDE*, glisser un TFDQuery, écrire SELECT *, et voir les données "live" dans un TDBGrid *sans jamais lancer l'application*.

La VCL est le framework "classique" de Delphi. Il est 100% Windows-natif.

C'est une vaste bibliothèque de composants (classes) qui "enveloppent" (wrap) directement les contrôles natifs de l'API Windows (GDI, User32). C'est pourquoi les applications VCL ont toujours un look "natif" parfait et sont très légères.

Composants VCL Incontournables (T...)

La convention est que tous les types (classes) VCL commencent par T (pour "Type").

Gestion des Événements

C'est la base de la VCL :

1. Vous placez un TButton (nommé Button1).
2. Dans l'Object Inspector, vous allez à l'onglet "Events".
3. Vous double-cliquez sur l'événement OnClick.
4. L'IDE vous bascule dans le code et crée le "squelette" de la méthode :

procedure TForm1.Button1Click(Sender: TObject);
begin
  // (Votre code ici)
  ShowMessage('Hello World!');
end;

FireMonkey (FMX) est le framework "dérivé", introduit en 2011 (Delphi XE2). C'est la réponse de Delphi au besoin de cross-platform.

VCL vs FMX

Philosophie FMX

Avec FMX, vous écrivez votre code (logique métier, accès FireDAC) une seule fois. Vous "dessinez" votre interface une fois sur le Form Designer, et vous pouvez la compiler pour *toutes* les plateformes.

FMX gère les "styles" natifs. Votre TButton FMX ressemblera à un bouton iOS sur iOS, et à un bouton Android (Material Design) sur Android, tout en utilisant le même code source.

// Ce code Object Pascal fonctionne à l'identique sur
// Windows, iOS, et Android grâce à FMX.

procedure TForm1.Button1Click(Sender: TObject);
begin
  // TEdit (VCL) -> TEdit (FMX)
  // ShowMessage (VCL) -> TDialogService.ShowMessage (FMX)
  TDialogService.ShowMessage('Hello ' + Edit1.Text);
end;

FireDAC est le "plugin" (la bibliothèque) moderne et universel de Delphi pour l'accès aux données. Il remplace les anciens BDE, ADO, et DBExpress.

Les 3 Composants de liaison ("Data-Aware")

C'est le "Data Binding" visuel de Delphi :

1. TFDConnection : La connexion (string de connexion vers SQL Server, PostgreSQL, MySQL, Oracle, SQLite, InterBase...).
2. TFDQuery (ou TFDTable) : La requête (SELECT * FROM ...). Il contient les données en mémoire.
3. TDataSource : Le "transformateur". C'est la colle invisible qui fait le lien entre les données (TFDQuery) et l'UI (TDBGrid).

Le Workflow (En Design-Time)

C'est ce qui rend Delphi si rapide pour les applications de gestion :

1. Glisser un TFDConnection (configurer la BDD).
2. Glisser un TFDQuery (écrire SELECT * FROM CLIENTS).
3. Glisser un TDataSource (le lier au TFDQuery).
4. Glisser un TDBGrid (une grille).
5. Dans l'Object Inspector du TDBGrid, régler sa propriété DataSource sur le TDataSource.

Résultat : La grille se remplit avec les données de la BDD *directement dans l'IDE*, avant même d'avoir lancé l'application. La pagination, l'édition, et la sauvegarde sont (presque) automatiques.

Delphi n'est pas *que* pour le Desktop. On peut l'utiliser pour construire des backends (serveurs d'API) REST ultra-performants (car natifs).

1. DataSnap (Legacy)

L'ancienne technologie multi-tiers de Borland. Elle était puissante mais complexe (utilisait DCOM, TCP/IP) et a été adaptée pour le REST/JSON.

2. RAD Server (Moderne)

C'est la solution "clé en main" d'Embarcadero pour déployer des APIs REST. C'est un serveur (basé sur WebBroker, le "Nginx" de Delphi) qui gère :

• La publication d'Endpoints REST (JSON).
• L'analyse (Analytics).
• La gestion des utilisateurs.

Exemple (Créer un endpoint /api/users)

// On crée un "Resource Module"
// On utilise des "Attributs" (comme en C#) pour définir les routes

[Path('users')] // -> /users
TUsersResource = class(TDataModule)
private
  FQuery: TFDQuery;
public
  [GET] // -> GET /users
  procedure GetUsers(Context: TEndpointContext);
  
  [GET, Path('{id}')] // -> GET /users/123
  procedure GetUser(Context: TEndpointContext; id: Integer);
end;

procedure TUsersResource.GetUsers(Context: TEndpointContext);
begin
  FQuery.SQL.Text := 'SELECT * FROM users';
  FQuery.Open;
  
  // Convertit le résultat de la BDD en JSON et l'envoie
  Context.Response.SetBody( FQuery.AsJSON );
end;

La véritable puissance de Delphi a toujours été son écosystème de composants tiers (plugins). C'est un marché de plusieurs millions de dollars. Vous pouvez acheter un composant, le glisser sur le Form, et ajouter des fonctionnalités (ex: un tableur Excel complet) à votre app en 10 minutes.

Gestionnaires de "Plugins"

Les "Big Players" (Addons Incontournables)

L'histoire de Delphi est longue et marquée par des "âges d'or". (Note : "RAD Studio" est la suite qui inclut Delphi et C++Builder).