Patterns
Remonter à Introduction aux concepts de modélisation
Les patterns fournissent aux développeurs de logiciels des fonctionnalités puissantes de réutilisation. Plutôt que d'essayer de résoudre chaque problème de conception depuis le tout début, vous pouvez utiliser les patterns prédéfinis. La hiérarchie des patterns est définie dans le registre de patterns. Vous pouvez gérer et organiser logiquement vos patterns à l'aide du Gestionnaire de patterns.
Sommaire |
Les patterns sont conçus pour :
- Créer des éléments fréquemment utilisés.
- Modifier des éléments existants.
- Implémenter dans votre modèle des groupes de projets ou des constructions de code source utiles.
Registre de patterns
Le registre de patterns définit la hiérarchie virtuelle des patterns. Vous pouvez créer des dossiers virtuels et regrouper les patterns logiquement pour satisfaire à vos exigences spécifiques. Toutes les opérations sur le contenu du registre de patterns s'effectuent dans le Gestionnaire de patterns et sont synchronisées avec le registre de patterns.
Gestionnaire de patterns
Le Gestionnaire de patterns permet une organisation logique des patterns (à l'aide d'arborescences, de dossiers et de raccourcis virtuels), ainsi que l'affichage et la modification des propriétés des patterns. Dans le Gestionnaire de patterns, vous travaillez avec les raccourcis aux patterns, et non avec les patterns réels. Les raccourcis au même pattern peuvent être inclus dans plusieurs dossiers.
Templates
La modélisation supporte les templates afin de fournir une compatibilité descendante avec les anciens projets des versions précédentes. Vous pouvez copier les dossiers avec vos anciens templates de code source dans le sous-dossier Patterns de votre répertoire d'installation, puis utiliser ces templates pour créer des éléments dans les projets d'implémentation.
Les templates, fichiers texte dotés d'extensions de noms de fichiers spécifiques au langage, utilisent des macros remplacées par des valeurs réelles quand les templates sont appliqués. Par conséquent, les templates peuvent être considérés comme des fiches prêtes au "remplissage" pour une instance spécifique. Un template se compose d'un fichier template contenant le code source et d'un fichier de propriétés qui contient les descriptions des macros et leurs valeurs par défaut.
Les templates sont stockés dans le sous-répertoire Patterns\templates de votre installation en utilisant la structure suivante :
/<language>/<category>/<template name>
où <category> est CLASS, LINK ou MEMBER. Chaque dossier <template_name> contient les fichiers suivants :
- %Name%.<ext>
- <template_name>,properties (facultatif)
Patterns de conception
Un pattern de conception est un fichier XML qui contient une séquence d'instructions, ou actions, servant à créer des entités et des liens et à définir leurs propriétés. Chaque instruction crée un élément de modèle ou un lien entre les éléments de modèles.
Outre la création de nouveaux éléments, les patterns de conception permettent d'ajouter des membres à un élément conteneur. La propriété Use Existent du pattern que vous appliquez à l'élément conteneur spécifié doit être définie sur True. Vous pouvez appliquer le pattern à l'élément conteneur que vous voulez modifier. Par exemple, si vous voulez ajouter plusieurs méthodes stockées en tant que pattern à une classe existante, vous devez alors appliquer ce pattern au diagramme contenant cette classe.
Les patterns de conception sont stockés sous forme de fichiers XML dans le répertoire Patterns de votre installation.
Patterns FCC (First Class Citizens)
Un pattern FCC (First Class Citizen) est un type spécifique de pattern de conception qui contient des informations sur le nom du pattern et le rôle de chaque participant. Appliqués à un diagramme, les patterns FCC créent leurs propres entités et sont présentés sur le diagramme avec les liens aux entités créées. De tels patterns permettent des modifications ultérieures par l'ajout de nouveaux participants.
Les patterns FCC sont représentés par des patterns GoF.
Sur un diagramme, un pattern prend la forme d'un ovale avec le nom du pattern et la liste extensible des participants. Chaque participant est connecté à l'ovale du pattern par un lien, libellé avec le rôle du participant.
Contrairement aux éléments de patterns FCC ovales, les patterns FCC génèrent du code source. Les entités créées par patterns sont stockées dans les fichiers diagrammes.
Pattern d'implémentation de stub
Quand vous créez un lien d'héritage entre une classe et une autre classe ou interface abstraite, les méthodes et membres se sont pas automatiquement ajoutés à la classe enfant. Ce problème est résolu à l'aide du pattern d'implémentation de stub. Vous pouvez aussi créer un lien d'implémentation et une implémentation de stub en une seule étape à l'aide du pattern stub et lien d'implémentation.
Si la destination d'un lien est une interface, le pattern d'implémentation Stub crée le source de classe implémentant cette interface et crée dans une classe les stubs pour toutes les méthodes déclarées dans l'interface et toutes ses interfaces parents.
Si le lien de destination est une classe abstraite, le pattern d'implémentation Stub indique au source de la classe d'étendre la destination de la classe et crée les stubs pour tous les constructeurs déclarés dans la destination de la classe. Ces stubs de constructeurs appellent les constructeurs correspondants dans la destination de la classe.
Vous pouvez trouver le pattern d'implémentation de lien et de stub dans l'expert Pattern. Pour ouvrir l'expert Pattern, utilisez les boutons Lien par pattern ou Noeud par pattern de la palette d'outils ou la commande Créer par pattern du menu contextuel d'une classe.
Le pattern d'implémentation de lien et de stub crée les membres suivants des interfaces et des classes abstraites :
- Méthodes
- Fonctions
- Sous-routines
- Propriétés
- Indexeurs
- Evénements