Utilisation de Delphi Prism

Nous retrouvons (avec plaisir) les applications Windows construites sur la plateforme Dot Net (qui, rappelons-le, avaient disparu avec Delphi 2007).

Pour créer notre application Windows Forms (WinForms pour les intimes) :

• lancez Delphi Prism par « Démarrer | Programs | Delphi Prism | Delphi Prism in Visual Studio 2008 »

• la version Delphi Prism de Visual Studio Shell est chargée, et la page de démarrage affichée (Ed : la fenêtre a été rapetissée pour éviter le défilement-écran dans votre explorateur .HTML)

• démarrez un nouveau projet par « File | New | Project » :

• un dialogue permettant de sélectionner le type de projet est présenté :

• sélectionnez « Delphi Prism | Windows | Windows Application » et cliquez « OK » ;
• au bout de quelques secondes, un projet WinForms vide est créé :

Notre première application va afficher la fenêtre en rouge par un clic sur un Button.

Nous récupérons le Button de la Toolbox (== la Palette). Par défaut, la Toolbox est repliée sur la gauche de la fenêtre.

Pour visualiser la Toolbox :

• promenez la souris du côté de l'icône située à la marge gauche (la flèche rouge)

• pour fixer (pinning) cette fenêtre, cliquez la « punaise » située en haut à droite de la Toolbar

Posons le Button et colorions la fenêtre en rouge :

• sélectionnez l'onglet « common controls », sélectionnez le Button et posez-le sur la forme ;
• cliquez deux fois sur le bouton ;
• la fenêtre de code est ouverte, et l'événement MainForm.button1_Click a été généré ;
• tapez le code pour colorier la fenêtre en rouge :

Compilons et exécutons :

• sélectionnez soit l'icône « start debugging » (flèche rouge) ou « start without debugging » (la flèche verte)

• la fenêtre est affichée :

Notez que :

• comme pour Delphi, lorsque le projet s'exécute, l'IDE présente les panneaux utiles pour suivre l'exécution (apparition des panneaux « Auto » et « Call Stack », suppression de la Toolbox et Property Inspector) ;
• nous avons fixé la Toolbox. Ceci n'est naturellement pas une obligation, et certains développeurs (en Delphi 2007 ou 2009) conservent des panneaux « mobiles » pour permettre une meilleure visibilité du code ;
• la zone centrale (« documents » comporte actuellement trois onglets. L'onglet « Start Page » peut être fermé sans grand préjudice en cliquant l'icône en haut à droite :

Vous pourrez toujours la rouvrir par « View | Other Window | Start page ».

Le Solution Explorer contient un certain nombre de fichiers. Pour mieux comprendre leur organisation, ajoutons une seconde fenêtre que nous allons afficher de façon modale.

Par conséquent :

• cliquez la petite flèche de la seconde icône de la Toolbar « add new item », et sélectionnez le premier élément « new item » (ou clic droit sur « Solution Explorer | WindowsApplication1 | Add | New Item » ou encore « Project | Add New Item »)

• le dialogue « New Item » est présenté

• cliquez « Windows Form » ;
• une nouvelle forme est créée :

• posez un composant sur Form1, par exemple une CheckBox ;
• retournez sur la forme principale par "Solution Explorer | double clic sur Main.Pas'

• posez un Button, créez son événement, et tapez le code qui ouvrira la forme de façon modale :

method MainForm.button2_Click(sender: System.Object; e: System.EventArgs);
  var l_form_1: Form1;
  begin
    l_form_1:= New Form1;
    if l_form_1.ShowDialog= System.Windows.Forms.DialogResult.Cancel
      then BackColor:= Color.Lime;
  end; // button2_Click

Notez que

• nous avons ajouté une CheckBox sur Form1, car sinon le compilateur se plaignait de l'absence de FORM1.RESX.

En examinant le Solution Explorer, la structure devient plus claire :

• le fichier PROGRAM.PAS est le point d'entrée principal qui lance la fenêtre MAIN ;

• pour chaque fenêtre, il y a trois fichiers :

  • xxx.PAS qui contient notre code,
  • xxx.DESIGNER.PAS qui crée les composants,
  • xxx.RESX un fichier qui contient les ressources (icônes, etc.) ;
• la fenêtre qui est lancée par le programme principal est appelée MAIN ;
• les autres fenêtres sont appelées FORM1, FORM2, etc.

Tous ces fichiers sont placés dans :

C:\Documents and Settings\ds\Mes documents\Visual Studio 2008\Projects\WindowsApplication1\WindowsApplication1

et voici le détail de ce répertoire (_data est un répertoire que nous avons ajouté pour nos bases de données DataSnap et Ado.Net, et qui n'a rien à voir avec cette application) :

Le code de MAIN.PAS est le suivant :

namespace WindowsApplication1;
  interface
    uses
      System.Drawing,
      System.Collections,
      System.Collections.Generic,
      System.Linq,
      System.Windows.Forms,
      System.ComponentModel;

    type MainForm =
             partial class(System.Windows.Forms.Form)
               private
                 method button1_Click(sender: System.Object; e: System.EventArgs);
                 method button2_Click(sender: System.Object; e: System.EventArgs);
               protected
                 method Dispose(disposing: Boolean); override;
               public
                 constructor;
             end; // MainForm

  implementation

    constructor MainForm;
      begin
        InitializeComponent();
      end; // MainForm

    method MainForm.Dispose(disposing: Boolean);
      begin
        if disposing then begin
          if assigned(components) then
            components.Dispose();
        end;
        inherited Dispose(disposing);
      end; // Dispose

    method MainForm.button1_Click(sender: System.Object; e: System.EventArgs);
      begin
        BackColor:= Color.Red;
      end; // button1_Click

    method MainForm.button2_Click(sender: System.Object; e: System.EventArgs);
      var l_form_1: Form1;
      begin
        l_form_1:= New Form1;
        if l_form_1.ShowDialog= System.Windows.Forms.DialogResult.Cancel
          then BackColor:= Color.Lime;
      end; // button2_Click

  end.

Notez que :

• le mot clé UNIT est remplacé par NAMESPACE ;
• la Classe est une Classe Partial. Nous retrouverons l'autre partie de cette Classe dans le fichier MAIN.DESIGNER.PAS ;
• les mots clés PROCEDURE et FUNCTION ont été remplacés par METHOD ;
• le CONSTRUCTOR n'a pas ce nom : c'est le constructeur par défaut ;
• la méthode MainForm et le Constructor sont dans une section (repliée par défaut dans l'IDE) ;
• les paramètres sont à la syntaxe .Net: e: System.Arg, le type dépendant en général de la méthode ;

• les composants et les propriétés sont ceux de .Net :

  • un type Button (au lieu de tButton),
  • une propriété BackColor (au lieu de Color),
  • une valeur Color.Red (le type de l'énuméré et la valeur) au lieu de la constante clRed,
  • pour créer un objet, il faut utiliser la nouvelle syntaxe New,
  • l'ouverture d'une fenêtre modale se fait par ShowDialog (au lieu de ShowModal),
  • la valeur de résultat modal se désigne par System.Windows.Forms.DialogResult.Cancel (au lieu de la constante mrCancel).

À part les nouveaux mots clés, l'utilisation de la notation .Net a déjà été abondamment présentée dans nos tutoriels précédents sur Delphi .Net.

Le contenu de MAIN.DESIGNER.PAS est le suivant :

namespace WindowsApplication1;
  interface
    uses
      System.Windows.Forms,
      System.Drawing;

    type MainForm =
            partial class
              private
                components: System.ComponentModel.Container := nil;
                button1: System.Windows.Forms.Button;
                button2: System.Windows.Forms.Button;
                method InitializeComponent;
              end;

  implementation

    method MainForm.InitializeComponent;
      begin
        var resources: System.ComponentModel.ComponentResourceManager
            := new System.ComponentModel.ComponentResourceManager(typeOf(MainForm));

        self.button1 := new System.Windows.Forms.Button();
        self.button2 := new System.Windows.Forms.Button();
        self.SuspendLayout();
        // -- button1
        self.button1.Location := new System.Drawing.Point(13, 13);
        self.button1.Name := 'button1';
        self.button1.Size := new System.Drawing.Size(75, 23);
        self.button1.TabIndex := 0;
        self.button1.Text := 'button1';
        self.button1.UseVisualStyleBackColor := true;
        self.button1.Click += new System.EventHandler(@self.button1_Click);
        // -- button2
        self.button2.Location := new System.Drawing.Point(13, 43);
        self.button2.Name := 'button2';
        self.button2.Size := new System.Drawing.Size(75, 23);
        self.button2.TabIndex := 1;
        self.button2.Text := 'button2';
        self.button2.UseVisualStyleBackColor := true;
        self.button2.Click += new System.EventHandler(@self.button2_Click);
        // -- MainForm
        self.ClientSize := new System.Drawing.Size(292, 273);
        self.Controls.Add(self.button2);
        self.Controls.Add(self.button1);
        self.Icon := (resources.GetObject('$this.Icon') as System.Drawing.Icon);
        self.Name := 'MainForm';
        self.Text := 'MainForm';

        self.ResumeLayout(false);
       end; // InitializeComponent

    end.

Notez que :

• la Classe est aussi Partial ;
• nous retrouvons bien la définition de nos deux Buttons ;
• la méthode InitializeComponent se charge de créer les composants par code (au lieu d'utiliser, comme Delphi Win32 un fichier .DFM qui est utilisé par une procédure de l'.EXE pour créer les composants). Au niveau de résultat, c'est strictement la même chose, mais, pour de nouveaux composants cela de s'inspirer de ces instructions de création pour créer des composants nous mène dynamiquement.
  Cette technique était aussi la même en Delphi 2006.Net.

Le code de PROGRAM.PAS est le suivant :

namespace WindowsApplication1;
  interface
    uses
      System.Threading,
      System.Windows.Forms;

    type Program = 
             assembly static class
               private
                 class method OnThreadException(sender: Object;
                     e: ThreadExceptionEventArgs);
               public
                 class method Main;
               end; // Program

  implementation

    [STAThread]
    class method Program.Main;
        // The main entry point for the application.
      begin
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.ThreadException += OnThreadException;
        using lMainForm := new MainForm do
          Application.Run(lMainForm);
      end; // Main

    class method Program.OnThreadException(sender: Object; 
        e: ThreadExceptionEventArgs);
        // Default exception handler
      begin
        MessageBox.Show(e.Exception.Message);
      end; // OnThreadException

    end.

Et nous constatons que :

• la Classe contenant le programme est définie comme une Assembly, ce qui, dans la terminologie .Net est similaire à « Module » en Win32 (.DLL ou .EXE) ;
• la Method de Classe Main crée bien la fenêtre principale et lance l'application.

Le fichier xxx.SLN (sln = Solution) correspond au projet. C'est celui-ci que nous cliquons lorsque nous souhaitons charger un projet.

Le fichier .EXE est situé dans BIN\DEBUG et ne fait que 32 K.

Notre Solution Explorer se présente ainsi :

Mentionnons simplement que :

• la zone référence contient les autres « assemblies » utilisées par notre projet. C'est ici qu'il faudra éventuellement ajouter des assemblies qui ne seraient pas importées automatiquement par Delphi Prism.

Naturellement, outre les changements de noms (Propriété au lieu d'Inspecteur d'objets, Toolbox au lieu de Palette) et d'emplacement (les Propriétés à droite au lieu de gauche, etc.), le plus déroutant pour les nouveaux arrivants dans le monde Visual Studio est la navigation et les raccourcis.

Voici donc un petit guide à ce sujet.

Visual Studio comporte deux types de panneaux :

• les « documents » qui sont situés dans le panneau central. Dans notre cas, c'est là que seront présentés :

  • les formes (designer),

  • les textes ,

    • essentiellement les fichiers de code,
    • ou d'autres fichiers (fichiers .XML, .CSS, etc. ;

• les « tools » qui sont utilisés pour manipuler les documents. Dans notre cas :

  • la Toolbox (et le Serveur Explorer situé dans un autre onglet),
  • les Properties qui contiennent les propriétés et les événements,
  • le Solution Explorer qui présente tous les fichiers utilisés par nos applications (dans l'onglet « Class View » une vue des Classes, mais qui n'est actuellement pas opérationnel),
  • les panneaux du bas (Output, Error list, dont nous n'aurons naturellement jamais besoin, etc.).

Tous ces éléments sont éminemment « dockables ».

Très vite la présentation initiale risque d'être modifiée, et de redocker les panneaux à un emplacement donné se révèle non trivial. Heureusement il existe un bouton « panique », accessible par « Window | Reset Window » que nous utilisons assez régulièrement (il existe vraisemblablement quelque part une possibilité de verrouiller le docking).

Pour un développeur, le plus crucial est la navigation Code/Forme.

Le plus simple est d'utiliser les icônes situées en haut du Solution Explorer. Naviguons par exemple entre le code et la Forme de Main :

• dans Solution Explorer, DOUBLE cliquez sur « Main »(ou sur « Main.Designer » !) ;
• la Forme de Main est affichée dans le panneau central des documents ;
• pour voir le code, cliquez sur l'icône « View Code »

pour retourner sur la Forme, nous pouvons utiliser l'icône « View Designer » située à côté de « View Code ».

Le panneau central ne peut pas être défilé. En revanche nous pouvons utiliser la petite flèche « Active Forms » située à côté de l'icône de fermeture de document.

Pour naviguer entre les panneaux nous pouvons utiliser

• Alt F7.

Par exemple

• sélectionnez Visual Studio ;
• tapez Alt F7 ;

• un dialogue présentant toutes les Tools est présenté :

  

• la frappe répétée de F7 présentera les Tools les uns après les autres.

Si par mégarde vous fermez une Tool, vous pouvez la réafficher par le menu « View ».

IV-D-1. Les Properties▲

Ce panneau affiche

• les propriétés du composant sélectionné sur la Forme ;
• un peu plus étonnant, les propriétés d'un fichier sélectionné (par simple clic) dans le Solution Explorer.

Pour les propriétés des composants, nous basculons des propriétés aux événements en cliquant l'icône « Events » située en haut des Properties :

IV-D-2. Raccourcis divers▲

Comme nous l'avons déjà présenté dans l'article sur les versions Delphi :

• Delphi 2006 .Net permettait de développer des applications utilisant la bibliothèque .Net

  • en utilisant directement la bibliothèque .Net

    • pour Windows Forms (non Internet),
    • pour Asp.Net (Internet),
  • en utilisant une couche d'adaptation pour avoir le même code que sous Win32, Vcl.Net. Le même code Win32 pouvait être compilé, en utilisant simplement une autre bibliothèque sous-jacente

soit :

et

• Rad Studio 2007 ne permettait plus que la création d'applications Asp.Net, mais avec la version 2.0 de .Net
• Delphi 2009 était purement Win32

Delphi PRISM permet donc à nouveau de réaliser des applications

• non Internet,
• Asp.Net pour Internet (plus des services Web)

et en ayant accès aux nouveautés de la version 3.5 de .Net.

Commercialement, Delphi PRISM est fourni avec « Rad Studio 2009 », avec Delphi 2009 pour la partie Win32, et Delphi PRISM pour la partie .Net

Certains regrettent l'abandon de Vcl.Net, qui permettait de compiler indifféremment avec la bibliothèque Win32 ou .Net. D'autres affirment que l'adaptation difficile entre deux bibliothèques assez différentes faisait de Vcl.Net un produit hybride, qui ne pouvait être parfait ni dans le monde Win32 ni dans celui de .Net.

Pour notre part, nous n'avons guère utilisé cette version Vcl.Net. À droite ou à gauche, mais pas au milieu. Pour des applications utilisant la syntaxe Win32 (les tEdit, les tStringlist), travailler directement en Win32 offre l'avantage de l'accès direct à la bibliothèque et de la performance (compilation, vitesse d'exécution, et, in fine, coût de développement).

Au contraire, la possibilité d'écrire du code Delphi (= Pascal objet) pour accéder en direct à la bibliothèque .Net (Clr, Fcl) nous paraissait une ouverture majeure. Force est de reconnaître que Microsoft, avec ses moyens, impose un peu la tendance. Par exemple les génériques et méthodes anonymes de Delphi 2009 « suivent » les concepts introduits par .Net2.0. Il reste donc important de garder un œil attentif sur les nouveautés introduites par .Net.

Vous l'avez compris, nous ne regrettons en rien l'abandon de Vcl.Net.

En revanche, nous avons du mal à comprendre pourquoi Codegear n'a pas pu adapter leur compilateur à la bibliothèque .Net3.5. Ils avaient déjà réalisé un compilateur « Delphi Pascal => .Net 2.0 », et avaient déjà un IDE sous la main.

RemObject a dû réaliser un travail bien plus important en adaptant leur compilateur « Pascal => .Net 3.5 » à la plateforme Visual Studio. Marc HOFFMAN de RemObject a souligné que la majeure partie de leur temps a été de trouver les points d'entrée dans Visual Studio, et que ceci n'a été possible que grâce à des contacts personnels avec les développeurs de Microsoft. Édifiant pour ceux qui souhaitent utiliser Visual Studio Shell.

Cette société a commencé par offrir une couche d'accès aux bases de données et aux objets, distribuée « Data Abstract ».

Puis elle a ajouté un compilateur « Pascal => .Net ». Lorsque Microsoft a lancé .Net, ils ont activement soutenu les organisations qui créaient des compilateurs de n'importe quel langage (Prolog, Fortran, Lisp, Pascal, etc.) vers le code intermédiaire MSIL (Microsoft Intermediate Language). L'environnement .Net se chargeait de passer du MSIL vers le code natif.

En octobre 2000 une version open source (Component Pascal, Université de Queensland) était disponible sur le Web. Nous ignorons si RemObject a utilisé ou non cette base pour créer sa première version « Pascal => .Net » (Chrome), mais cette version a été une base pour explorer certaines extensions de Delphi Pascal.

RemObjects a ensuite proposé le compilateur Oxygen.

C'est ce compilateur qui a été intégré à Delphi PRISM.

Delphi PRISM

• Microsoft offre

  • un Ide générique « vide » comportant un inspecteur d'objet, une palette et une zone pour les « documents ».
    Les personnes souhaitant utiliser cet Ide installent leur produit par dessus, et c'est ce qu'a réalisé RemObjects ;

  • la bibliothèque .Net. Donc

    • une couche de gestion (compilateur, gestionnaire mémoire, vérification des types),
    • une bibliothèque de composants (Edit, Collection) ;

• RemObject ajoute

  • un compilateur « Pascal » vers le code intermédiaire .Net,
  • le raccordement entre ce langage et l'Ide et la bibliothèque .Net,
  • accessoirement la bibliothèque Data Abstract ;

• Codegear encapsule le tout

  • en ajoutant la couche d'accès aux données dbx4 / DataSnap et Blackfish Sql.

VI-D-1. Le code Delphi Pascal▲

VI-D-2. Quant à l'IDE▲

VI-D-3. Linux et Mac▲

VI-D-4. L'aide et la documentation▲

C'est peut-être là que le bât blesse.

Actuellement F1 n'est pas implémenté, mais devrait être ajouté par la suite.

La documentation est proposée sous forme de Page Wikipédia :

Notez que

• il est recommandé de télécharger régulièrement les mises à jour, la version initiale (4 Meg) étant constamment enrichie (12 Meg pour notre téléchargement février 2009) ;
• ATTENTION, il existe aussi Delphi Prism qui est un Wiki sans le soutien de Codegear, et plutôt creux ;
• pour avoir une vision plus épurée et hiérarchique de ce Wiki, nous avons créé un outil qui présente les fichiers .HTML avec un accès par TreeView :

qui est en cours de publication

Ce qui manque le plus est l'aide .Net. Pour Delphi 2006 et 2007, Codegear avait licencié l'aide Microsoft. Même si les exemples sont en C#, c'était une source inestimable pour explorer la bibliothèque (les Classes, leurs relations, les propriétés, événements et méthodes) et pour les exemples très nombreux. Sans ce type de document, comment donc deviner que pour ouvrir un dialogue il faut utiliser « ShowDialog » et pas « ShowModal » ?

La page « téléchargement recommandé » de Delphi Prism suggère de télécharger le Visual Studio SDK (136 Megs, 6 heures à 61 Kbd).

Pour le moment, nous utilisons l'aide Microsoft fournie avec Delphi 2007.

La situation n'est pas sans espoir :

• pour ceux qui ont Delphi 2006 ou 2007, utiliser l'aide Microsoft ;
• télécharger le Sdk Microsoft ;

• utiliser l'Object Browser (« View | Object Browser », alias « Alt Ctrl J ») :

  

• user et abuser du « code completion ». Un de nos clients m'a récemment montré une technique à laquelle je n'avais pas pensé : pour visualiser les méthodes et propriétés d'une Forme, taper « Self. » (Self et un point) ;

• finalement, F1 devrait arriver

• utiliser les newsgroups Delphi PRISM.
  Nous avons utilisé nos aspirateur Internet (déjà publiés en source) pour avoir une copie locale ayant un moteur de recherche avec AND, OR, NOT, parenthèses, etc. Mais naturellement la version en ligne est aussi utilisable.

• faire appel à MSDN (le site d'information développeur Microsoft), les sites .Net (comme Code Project), ou, plus généralement Google.

Nick HODGES a publié une Roadmap PRISM qui a été traduite en français par Thierry LABORDE. Cette feuille de route indique que :

• l'intégration d'accès aux bases de données va s'étoffer. En particulier

  • la possibilité de créer des serveurs DataSnap,
  • l'utilisation de l'« Entity Framework » qui semble le remplaçant de LINQ,
• l'intégration de Nunit, l'environnement de test unitaire.

En conclusion

• Delphi PRISM nous permet de « recoller » aux nouveautés Microsoft ;
• les personnes ayant déjà utilisé une version Delphi .Net seront rapidement opérationnelles, ayant uniquement à se familiariser avec Visual Studio ;
• en revanche débuter dans le monde .Net en utilisant Delphi PRISM ne sera pas évident compte tenu de la documentation actuelle. Naturellement des articles sur Developpez ou ailleurs - :) - vous aideront à découvrir ce monde nouveau.

Et compte tenu de la position privilégiée de Delphi PRISM (syntaxe Delphi PASCAL avec accès au monde .Net), nous avons déjà organisé des Formations Delphi PRISM.