|
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 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.
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 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 la
développement de projets pour
ses clients, le conseil 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, Ado.Net, Asp.Net et UML qu'il
anime personellement tous les mois, à Paris, en province ou sur site client.
|
