|
UML avec Delphi - John COLIBRI. |
- résumé : comment créer des diagrammes UML avec Delphi et Together: diagramme de classe, cas d'utilisation et diagramme de séquence. Avec génération de code et synchronisation entre le code Pascal et les diagrammes
- mots clé : diagrammes UML - Together Soft - diagramme de classe - diagramme de cas d'utilisation - diagramme de séquence
- logiciel utilisé : Windows XP personnel, Delphi 2006
- matériel utilisé : Pentium 2.800 Mhz, 512 Meg de mémoire, 250 Giga disque dur
- champ d'application : Delphi 2006 ou Turbo Delphi
- niveau : développeur Delphi
- plan :
1 - Diagrammes UML et Delphi Nous allons indiquer comment utiliser Delphi pour créer des diagrammes UML, générer le code correspondant et synchroniser le code et les diagrammes.
Cet article ne présente rien qui ne soit pas déjà dans la documentation. Toutefois les étapes sont plus détaillées, avec les figures à chaque pas. Mentionnons que: - cet article n'a pas pour vocation de vous initier à UML. Il permet
simplement de rapidement arriver à utiliser Delphi pour créer, modifier et synchroniser les diagrammes
En fait nous avons rédigé ce tutorial, car nous avons remarqué que les
personnes en formation UML avaient souvent quelques difficultés à savoir quelles parties de Delphi utiliser pour arriver à leurs fins.
- nous ne présentons pas TOUS les diagrammes possibles. Seuls les diagrammes
de classe, de cas d'utilisation et de séquence sont abordés. Le lecteur qui aura suivi ces exemples n'aura aucune difficulté à aborder les diagrammes d'état ou d'activité
- le logiciel utilisé pour le tutorial est Delphi 2006. Les exemples de
diagrammes de classe fonctionnent pour la version gratuite de Turbo Delphi, mais pas les diagrammes de cas d'utilisation ou de pour les diagrammes de séquence. Pas grave, ils sont bien moins importants que les diagrammes de classe
Et le petit clin d'oeil de notre sponsor: - nous animons régulièrement des
Formations UML et Design
Pattern dont le but est de présenter les techniques d'analyse et conception objet, utilisant UML comme notation graphique. La création de diagramme UML y sont abordés, mais surtout comme un outil pour la création,
la documentation et la maintenance de projets industriels.
2 - Diagramme de classe UML 2.1 - Gestion de comptes chèques et comptes épargne
Une application doit gérer deux types de comptes: compte chèque et épargne. Nous utiliserons donc une class compte ancêtre et deux descendants pour la gestion des chèques ou des épargnes.
2.2 - Création du Modèle Delphi
Commençons par créer le modèle Delphi 2006:  | lancez Delphi 2006
| 
| l'interface vierge est présentée:  | | |
sélectionnez "File | New | Vcl Application - Win32" pour créer une nouvelle application Win32
| | | la Forme traditionnelle est présentée
|
| | sauvegardez le projet sous p_bank / u_bank
| | | voici les fichiers sur disque
 et voici la Forme, avec, à droite, le gestionnaire de projet sélectionné (onglet désigné par la flèche rouge)
 | | | pour créer les fichiers permettant la modélisation, sélectionnez l'onglet
"model" (désigné par la flèche jaune)
| | | Delphi nous demande de confirmer la création du modèle:
 | | | cliquez "Oui" | |
| Delphi prépare les fichiers pour gérer le modèle 
et présente l'arborescence du modèle dans le notebook de droite:  | | |
pour voir les éléments du modèle, cliquez sur le "+" de l'icône "p_bank" (en vidéo bleu) | | |
Delphi présente le TreeView des éléments du projet, qui contient donc p_bank et u_bank: 
|
Nous allons à présent créer un diagramme qui représente notre modèle. Pour cela: | | cliquez deux fois sur l'icône "u_bank" (une petit icône bleue)
|
| | Delphi crée une nouvelle page avec le graphique, et en même temps
- expande l'élément du Treeview représentant u_bank
- présente ses propriétés dans l'Inspecteur d'Objet
- et prépare la palette avec de nouveaux éléments graphiques:
|
En gros, la surface graphique - est une sorte de diagramme de classe UML
- qui nous indique que la CLASS tForm1 descend de l'ancêtre tForm
ce que le source Delphi confirme:
unit u_bank;
interface
uses Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms, Dialogs;
type TForm1= class(TForm)
private
public
end; // TForm1
var Form1: TForm1;
// |
Ce qu'il est fondamental de comprendre est que pour pouvoir gérer les éléments du modèle, il faut préparer une surface de dessin, et ceci se fait
- en préparant le modèle (sélection de l'onglet "Model" du NoteBook en haut à droite
- en double cliquant sur une icône bleue
Une fois que nous avons une surface de dessin, nous pouvons ajouter des éléments de graphique UML - soit par click droit sur l'icône bleue
- soit par click droit sur la surface de dessin
et des menus contextuels nous proposent alors les différentes possibilités A titre d'exemple, ajoutons une CLASS à notre diagramme: | |
sélectionnez dans le Treeview de "Model View" l'icône bleue de u_bank
| | | un clic droit souris présente un menu contextuel
| |
| sélectionnez "Add | Class"  | |
| une nouvelle classe est ajoutée au diagramme: et la classe a été ajoutée au source Pascal:
unit u_bank;
interface
uses Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms, Dialogs;
type TForm1= class(TForm)
private
public
end; // TForm1
Class1= class
end;
var Form1: TForm1;
// |
|
Comme cette classe ne nous servira plus, vous pouvez la supprimer:
2.3 - Ajout des comptes chèque et épargne Pour pouvoir isoler nos nouvelles classes, nous allons créer une unité spéciale
et les placer dans cette unité. Cela simplifiera les diagrammes et le source Pascal. Par conséquent
Nous allons placer nos classes dans un diagramme de classes UML. Nous créons
donc un tel diagramme vierge:
Ajoutons notre classe ancêtre
Ajoutons les attributs "nom du client", "numéro de compte" et "solde": | | dans le diagramme de classe, sélectionnez "c_account", clic droit sur le
titre de la classe et "Add | Field"
| | | Delphi va ajouter un champ:  |
| | renommez le champ "m_customer: String" Agrandissez la classe c_account (sinon vous ne verrez pas son contenu) | |
| voici le nouveau champ:  | | |
ajoutez de même les champs "m_account_number: String" et "m_balance: Double" Notez que ces champs ne sont pas nécessairement affichés dans l'ordre d'ajout. Le source Pascal (onglet "p_bank", cliquez "u_c_account"), en
revanche, les présente dans l'ordre d'ajout: unit u_c_account;
interface
type c_account = class
public
var
m_customer:String;
m_account_number:String;
m_balance:Double;
end;
implementation
end.
|
|
Ajoutons à présent la procédure qui va ajouter un montant au compte: deposit(123) | |
dans le diagramme de classe, sélectionnez "c_account", clic droit SUR LE TITRE de la classe et "Add | Procedure", et tapez "deposit"
| | |
dans l'Inspecteur d'Objet, sélectionnez Params et ajoutez p_amount: Double | | | voici la saisie:
 | | | Tapez Entrée
| |
| le diagramme de la classe n'affiche pas les paramètres ajoutés, mais le source Pascal les contient bien:
unit u_c_account;
interface
type c_account = class
public
procedure deposit(p_amout: Double);
var
m_customer:String;
m_account_number:String;
m_balance:Double;
end;
implementation
procedure c_account.deposit(p_amout: Double);
begin
end;
end.
|
|
2.4 - Classes descendantes Nous allons à présent ajouter la classe compte chèque, qui descend de c_account. Nous pourrions lui ajouter, par exemple, un dépot initial minimum
et un découvert plafond (alors qu'un compte épargne aurait un taux d'intérêt). Il est possible de créer le diagramme de cette classe par clic droit dans "Model View" ou sur le diagramme de classe. Nous allons utiliser une autre
technique, en passant par la Palette: | | dans "Model View", sélectionnez le diagramme de classe "Class Diagram" (p_bank | u_c_account | Class Diagram)
|
| | dans la Palette, sélectionnez "Class"  et posez-la sur le diagramme:
| | | renommez la classe "c_checking_account"
|
Cette classe doit descendre de "c_account": |
| dans la Palette, sélectionnez l'icône "generalization" (qui est le nom UML pour l'héritage) 
| | | cliquez sur "c_checking_account", tirez la souris au dessus de "c_account" et lachez-la | |
| le diagramme affiche l'héritage entre ces deux classes: 
Le source Pascal a bien créé une classe qui hérite de c_account:
unit u_c_account;
interface
type c_account = class
public
procedure deposit(p_amout: Double);
var
m_customer:String;
m_account_number:String;
m_balance:Double;
end;
c_checking_account = class(c_account)
end;
implementation
procedure c_account.deposit(p_amout: Double);
begin
end;
end.
|
|
2.5 - Live Source Pour le moment, nous avons surtout utiliser l'onglet "Model View", et Delphi générait le code Pascal correspondant dans l'UNITé.
Le trajet inverse est aussi possible. Si nous modifions le texte Pascal, nous pouvons mettre à jour le diagramme de classe. A titre d'exemple, ajoutons les champs "dépot initial" et "découvert maximum" à notre compte chèque:
Il est même possible de générer tous les diagrammes de classe en chargeant un nouveau projet, en forçant la création d'un modèle (voir le début de l'article) et en rafraîchissant le modèle.
3 - Les Diagrammes UML avec Delphi
3.1 - Les Diagrammes UML Nous avons créé un diagramme de Classe UML. Pour la version gratuite de Turbo Delphi (Win32), c'est le seul diagramme UML
que nous puissions créer. Pour ceux qui seraient angoissés de manquer quelque chose, mentionnons que les diagrammes de classe représentent 90 % des diagrammes UML "utiles". C'est là une opinion personnelle, mais si quelqu'un
vous affirme le contraire, demandez lui donc de vous montrer les autres diagrammes qu'il utilise réellement, et sur un projet industriel concret, et jugez par vous-même.
Pour Delphi 2006, nous pouvons aussi créer les autres diagrammes UML. Si nous sélectionons "Model View | u_c_account | Add | other diagrams", un dialogue affiche les diagrammes disponibles:
3.2 - Cas d'utilisation Dessinons, par exemple, le diagramme des cas d'un distributeur de billet: |
| vérifiez que "u_c_account" est bien sélectionné dans "Model View"
| | |
clic droit souris, puis "Add | other diagram"
| | | le dialogue présente les diagrammes utilisables
| |
| sélectionnez "use case diagram"
| | |
un nouveau diagramme "use case diagram" est ajouté à notre modèle et la Palette présente les éléments que nous pouvons poser sur un diagramme de case d'utilisation
| |
| dans la Palette, sélectionnez "Actor": 
et posez-le sur le diagramme de cas d'utilisation. Renommez d'acteur "user" | | | voici le diagramme avec notre acteur:
 | | | sélectionnez dans la Palette l'icône représentant les limites du système
 et posez-la au milieu du diagramme Renommez le système atm (Automatic Teller Machine= distributeur de billets) |
| | sélectionnez dans la Palette l'icône représentant un cas:  et posez le cas en haut du système
Renommez ce cas "withdraw money" | | | dans la Palette sélectionnez "communicates", et tirez-glissez le lien
entre l'acteur "user" et le cas "withdraw money" | | | voici notre cas d'utilisation: 
|
3.3 - Diagramme de séquence Finalement, voici un diagramme de séquence qui est utilisé pour modéliser le comportement dynamique de notre système. Nous allons débuter le diagramme
représentant un utilisateur qui retire du liquide: il insère sa carte, le système vérifie sa validité, l'utilisateur tape son code etc. Donc:
3.4 - Le diagramme de u_c_account Si nous sélectionnons dans "Model View" l'icône bleue "u_c_account", voici ce
que nous obtenons:  Ce diagramme résume les éléments UML contenus dans le modèle de "u_c_account" - l'unité
- nos deux classes c_account et c_checking_account
- les trois diagrammes que nous avons ajoutés, présentés ici sous forme de "package"
En cliquant sur l'un des diagrammes, le détail du diagramme sera présenté.
Pour terminer, voici la page principale correspondant du projet UML phare de Delphi 2006, "Cash Sales" (en C#) situé en C:\Program Files\Borland\BDS\4.0\Demos\Modeling\CSCashSales
En sélectionnant "Model View | CsCashSales" nous obtenons:  qui permet d'accéder à 12 diagrammes en tout.
4 - Commentaires sur Delphi et Together Dans cet article, nous avons été très détaillé sur chaque figure. La raison est que si vous ne sélectionnez pas le bon élément du TreeView modèle pour ajouter
ou modifier des éléments, Together (l'outil UML intégré à Delphi) ne fera pas le travail escompté. En fait cela fait partie de quelques critiques concernant l'ensemble:
- sur la vue modèle, il y a trop de monde. Trop de petites icônes, ayant chacune une signification propre, avec pas mal de duplication
- la séparation entre onglets "gestionnaire de projet", "modèle", "explorateur
de données" n'est pas la meilleure possible
- l'explorateur de données joue bien son rôle
- entre le "gestionnaire" et le "modèle", il y a un certain mélange:
- le gestionnaire permet d'accéder à des diagrammes (parce qu'ils
correspondent à des fichiers, je suppose)
- le modèle permet d'accéder au code Pascal
Si j'avais un voeu pour l'avenir, - je spécialiserais le gestionnaire dans les données autres que celles des diagrammes
- je limiteraiq le modèle à la présentation et l'organisation des diagrammes, sans présenter le détail de chaque élément de diagramme. Pour le détail, les éléments sont sur chaque diagramme. Un peu comme
l'explorateur Windows qui à gauche présente les dossier et à droite le détail des fichiers. Je supprimerais aussi les duplications, ainsi que "Default" et "References" de ce TreeView
Ce léger reproche et d'ailleurs aussi valable pour ModelMaker: de trop nombreuses fenêtres nichées dans l'écran, avec des myriades de grigris servant à piloter l'ensemble.
Avant que Delphi ne permette d'utiliser Together pour les projets autres que ceux débouchant sur ECO, nous avons enrichi notre outil graphique (notre éditeur de dessin que nous utilisons depuis plus de 20 ans) pour réaliser le
travail d'analyse et modélisation: - l'éditeur utilise un Treeview pour organiser et gérer les diagrammes
- la surface de dessin contient les éléments de chaque diagramme
- des .EXE externes permettent d'analyser les fichiers des paramètres des diagrammes pour générer le code Delphi correspondant
- et réciproquement pour le reengineering, un .EXE génère les fichiers de paramètres graphiques
L'essentiel, de notre point de vue, est de pouvoir modéliser le plus efficacement possible. Si pour entrer dix attributs, il faut effectuer un clic droit et une sélection pour ajouter chaque nouvel attribut, par exemple, cela finit par lasser.
Quel que soit l'outil que vous choisissiez, l'essentiel est de maîtriser les manipulations nécessaires le plus rapidement possible, pour arriver à procéder à votre analyse et votre conception.
5 - Télécharger le code source Delphi Vous pouvez télécharger: - uml_avec_delphi.zip : le projet Delphi 2006 contenant tout le projet, y
compris le modèle complet (22 K)
Ce .ZIP qui comprend: - le .DPR, la forme principale, les formes annexes eventuelles
- les fichiers de paramètres (le schéma et le batch de création)
- dans chaque .ZIP, toutes les librairies nécessaires à chaque projet (chaque .ZIP est autonaume)
Ces .ZIP, pour les projets en Delphi 6, contiennent des chemins RELATIFS. Par conséquent:
- créez un répertoire n'importe où sur votre machine
- placez le .ZIP dans ce répertoire
- dézippez et les sous-répertoires nécessaires seront créés
- compilez et exécutez
Ces .ZIP ne modifient pas votre PC (pas de changement de la Base de Registre, de DLL ou autre). Pour supprimer le projet, effacez le répertoire. La notation utilisée est la notation alsacienne qui consiste à préfixer les
identificateurs par la zone de compilation: K_onstant, T_ype, G_lobal, L_ocal, P_arametre, F_unction, C_lasse. Elle est présentée plus en
détail dans l'article La Notation Alsacienne
Comme d'habitude:
- nous vous remercions de nous signaler toute erreur, inexactitude ou problème de téléchargement en envoyant un e-mail à jcolibri@jcolibri.com. Les corrections
qui en résulteront pourront aider les prochains lecteurs
- tous vos commentaires, remarques, questions, critiques, suggestion d'article, ou mentions d'autres sources sur le même sujet seront de même
les bienvenus à jcolibri@jcolibri.com.
- plus simplement, vous pouvez taper (anonymement ou en fournissant votre e-mail pour une réponse) vos commentaires ci-dessus et nous les envoyer en
cliquant "envoyer" :
- et si vous avez apprécié cet article, faites connaître notre site,
ajoutez un lien dans vos listes de liens ou citez-nous dans vos blogs ou réponses sur les messageries. C'est très simple: plus nous aurons de visiteurs et de références Google, plus nous écrirons d'articles.
6 - L'auteur John COLIBRI est passionné par le développement Delphi et les applications de Bases de Données. Il a écrit de nombreux livres et articles, et partage son temps entre le développement de projets (nouveaux projets, maintenance, audit, migration BDE, migration Xe_n, refactoring) pour ses clients, le
conseil (composants, architecture, test) et la
formation. Son site contient des articles
avec code source, ainsi que le programme et le calendrier des stages de formation Delphi, base de données, programmation objet, Services Web, Tcp/Ip et
UML qu'il anime personellement tous les mois, à Paris, en province ou sur site client.
|
