Diagrammes de classes UML : indications

Dans Visual Studio Ultimate, vous pouvez utiliser un diagramme de classes UML pour décrire des types de données et leurs relations, indépendamment de leur implémentation.Le diagramme permet de se concentrer sur les aspects logiques des classes, plutôt que sur leur implémentation.

Pour créer un diagramme de classes UML, dans le menu Architecture , choisissez Nouveau diagramme.

[!REMARQUE]

Cette rubrique concerne les diagrammes de classes UML.Il existe un autre genre de diagramme de classes, que vous pouvez créer et utiliser pour visualiser le code du programme.Consultez classes et types concevants et de visionnements.

Dans cette rubrique

Utilisation de diagrammes de classes UML

Étapes de base pour le dessin de diagrammes de classes

Utilisation de classes, d'interfaces et d'énumérations

Attributs et opérations

Dessin et utilisation d'associations

Héritage

Types de modèles

Définition d'espaces de noms avec des packages

Le code de génération de diagrammes de classes UML

Utilisation de diagrammes de classes UML

Vous pouvez utiliser un diagramme de classes UML à diverses fins :

• Pour fournir une description indépendante de l'implémentation des types utilisés dans un système et passés entre ses composants.

  Par exemple, le type Commande de repas peut être implémenté dans le code .NET de la couche métier, dans le XML au niveau des interfaces entre les différents composants, dans les bases de données SQL, ainsi que dans l'interface utilisateur du HTML.Bien que ces implémentations diffèrent dans les détails, la relation entre Commande de repas et les autres types, tels que Menu et Paiement, est toujours la même.Le diagramme de classes UML permet d'évoquer ces relations indépendamment des implémentations.

• Pour clarifier le glossaire des termes utilisés pour la communication entre l'application et ses utilisateurs, ainsi que dans les descriptions de leurs besoins.Consultez Modélisation des besoins des utilisateurs.

  Par exemple, considérez les descriptions des récits utilisateur, des cas d'usage ou des autres impératifs d'une application de restaurant.Dans une telle description, vous recherchez des termes tels que Menu, Commande, Repas, Prix, Paiement, etc.Vous pouvez dessiner un diagramme de classes UML qui définit les relations entre ces termes.Cela réduira le risque d'incohérences dans les descriptions d'impératifs, dans l'interface utilisateur et dans les documents d'aide.

Relation aux autres diagrammes

Un diagramme de classes UML est généralement dessiné avec d'autres diagrammes de modélisation, afin de fournir des descriptions des types qu'ils utilisent.En tous les cas, la représentation physique des types n'est pas impliquée par l'un des diagrammes.

Étapes de base pour le dessin de diagrammes de classes

Pour obtenir des informations de référence concernant les éléments de diagrammes de classes UML, consultez Diagrammes de classes UML : référence.

[!REMARQUE]

Les étapes détaillées de création de l'un des diagrammes de modélisation sont décrites dans Comment : modifier des modèles et diagrammes UML.

Pour créer un diagramme de classes UML

1. Dans le menu Architecture , choisissez Nouveau diagramme.

2. Sous Modèles, choisissez Diagramme de classes UML.

3. Nommez le diagramme.

4. Dans Ajouter au projet de modélisation, sélectionnez un projet de modélisation existant dans votre solution, ou Créer un nouveau projet de modélisation, puis choisissez OK.

   Un nouveau diagramme de classes apparaît avec la boîte à outils Diagramme de classesUML.La boîte à outils contient les relations et éléments requis.

Pour dessiner un diagramme de classes UML

1. Pour créer un type, choisissez Classe, Interface ou l'outil Énumération de la boîte à outils, puis sur une partie vide du diagramme.

   Vous pouvez également créer des types basés sur des types dans votre code.Vous pouvez faire glisser des types de l'explorateur de solutions, de navigateur de l'architecture, ou graphiques de dépendance vers le diagramme.Consultez Comment : créer des diagrammes de classes UML à partir du code.

2. Pour ajouter des attributs ou des opérations aux types, ou des littéraux à une énumération, choisissez Attributs, Opérations ou Littéraux en-tête est du type, puis appuyez sur ENTRÉE.

   Vous pouvez écrire une signature telle que f(x:Boolean):Integer.Consultez l' Attributs et opérations.

   Pour ajouter plusieurs éléments rapidement, appuyez deux fois sur ENTRÉE à la fin de chaque élément.Vous pouvez utiliser les touches de direction pour vous déplacer vers le haut ou le bas de la liste.

3. Pour développer ou réduire un type, choisissez l'icône en forme de chevron à son supérieur gauche.Vous pouvez également développer et réduire les sections Attributs et Opérations d'une classe ou d'une interface.

4. Pour dessiner des liens d'associations, d'héritage ou encore de dépendance entre les différents types, cliquez successivement sur l'outil de relation approprié, sur le type source et sur le type cible.

5. Pour créer des types dans un package, créez un package à l'aide de l'outil Package, puis créez-y des types et des packages.Vous pouvez également utiliser la commande de copie pour copier des types et les coller dans un package.

6. Un diagramme est une vue dans un modèle partagé entre les autres diagrammes du même projet.Pour afficher une arborescence du modèle complet, choisissez Afficher, Autres fenêtres, Explorateur de modèles UML.

Utilisation de classes, d'interfaces et d'énumérations

Il existe trois genres standard de classifieurs disponibles dans la boîte à outils.Dans ce document, ils sont connus sous le nom de types.

• La plupart du temps, vous pouvez utiliser Classes (1) pour représenter des types de données ou d'objets.

• Utilisez Interfaces (2) dans un environnement dans lequel vous devez distinguer les interfaces pures et les classes concrètes qui disposent d'implémentations internes.Cette différence est utile lorsque l'objectif du diagramme consiste à décrire une implémentation logicielle.Celle-ci est moins utile lorsque vous modélisez des données passives ou que vous définissez des concepts permettant de décrire les besoins des utilisateurs.

• Utilisez une Énumération (3) pour représenter un type qui dispose d'un nombre limité de valeurs littérales (par exemple, Stop et Go).

  • Ajoutez les valeurs littérales à l'énumération.Attribuez à chacune un nom bien distinct.

  • Si vous le souhaitez, vous pouvez également fournir une valeur numérique pour chaque valeur littérale.Ouvrez le menu contextuel du littéral dans l'énumération, choisissez Propriétés, puis tapez un nombre dans le champ Valeur dans la fenêtre Propriétés .

Attribuez un nom unique à chaque type.

Obtention de types d'autres diagrammes

Vous pouvez faire apparaître des types d'un autre diagramme dans votre diagramme de classes UML.

Autre type de diagramme	Comment obtenir des types de l'autre diagramme
Diagramme de classes UML	Vous pouvez faire apparaître une classe sur plusieurs diagrammes de classes UML.Après avoir créé une classe dans un diagramme, faites-la glisser depuis l'Explorateur de modèles UML vers l'autre diagramme. Cette opération est utile si vous souhaitez que chaque diagramme se concentre sur un groupe particulier de relations. Par exemple, vous pourriez afficher les associations entre une Commande de repas et le Menu de restaurant dans un diagramme, de même que celles entre Commande de repas et Paiement, dans un autre.
Diagramme de composant	Si vous avez défini des composants dans un diagramme de composant, vous pouvez faire glisser un composant depuis l'Explorateur de modèles UML vers le diagramme de classes.Celui-ci apparaîtra alors en tant que classe.Consultez Diagrammes de composants UML : indications.
Diagramme de séquence UML	Vous pouvez créer des classes et des interfaces à partir des lignes de vie d'un diagramme de séquence, puis faire glisser la classe depuis l'Explorateur de modèles UML vers un diagramme de classes UML.Chaque ligne de vie d'un diagramme de séquences représente une instance d'objet, de composant ou encore d'acteur. Pour créer une classe d'une ligne de vie, ouvrez le menu contextuel de la ligne de vie, puis choisissez Créer la classe ou Créer l'interface.Consultez Diagrammes de séquence UML : indications.
Le code du programme	Vous pouvez représenter des types de votre code du modèle.Faites glisser les classes, les interfaces, ou les énumérations du navigateur de l'architecture ou des graphiques de dépendance vers un diagramme de classes UML. Les types que vous faites glisser apparaissent sur le diagramme.Les types dépendants sont également ajoutées au modèle.Lorsqu'un type UML a été créé de cette manière, vous pouvez le double-cliquez sur pour ouvrir le code source.Consultez Comment : créer des diagrammes de classes UML à partir du code. Remarque Le code et le modèle ne sont pas conservés synchronisé.Vous pouvez mettre à jour le diagramme pour évoquer les propositions de modification sans affecter votre code.Les modifications suivantes du code n'affecteront pas automatiquement le diagramme à moins de faire glisser à nouveau les types sur le diagramme.

Attributs et opérations

Un attribut (4) est une valeur nommée que chaque instance de type peut posséder.L'accès à un attribut ne modifie pas l'état de l'instance.

Une opération (5) est une méthode ou une fonction que les instances du type peuvent exécuter.Elle peut retourner une valeur.Si la valeur true est affectée à sa propriété isQuery, celle-ci ne peut pas modifier l'état de l'instance.

Pour ajouter un attribut ou une opération à un type, ouvrez le menu contextuel du type, choisissez Ajouter, puis choisissez Attribut ou Opération.

Pour consulter ses propriétés, ouvrez le menu contextuel pour l'attribut ou l'opération, puis choisissez Propriétés.Les propriétés s'affichent dans la fenêtre Propriétés.

Pour afficher les propriétés des paramètres d'une opération, choisissez […] dans la propriété Paramètres .Une nouvelle boîte de dialogue de propriétés apparaît alors.

Pour plus d'informations sur les propriétés que vous pouvez définir, consultez :

• Propriétés d'attributs dans des diagrammes de classes UML

• Propriétés d'opérations dans des diagrammes de classes UML

Types d'attributs et d'opérations

Chaque Type d'attribut ou d'opération, de même que chaque type de paramètre, peuvent être l'un des éléments suivants :

• (aucun) - Vous pouvez laisser un type non spécifié dans la signature en omettant les deux-points précédents (:).

• Un des types primitifs standard : Booléen, Entier, Chaîne.

• Type défini dans votre modèle.

• Valeur paramétrable d'un type de modèle, modèle écrit < Parameter >.Consultez Types de modèles.

Vous pouvez également écrire le nom d'un type que vous n'avez pas encore défini dans votre modèle.Le nom figurera sous Types non spécifiés dans l'explorateur de modèles UML.

[!REMARQUE]

Si vous définissez ensuite une classe ou une interface de ce nom dans votre modèle, les attributs et les opérations antérieurs feront encore référence à l'élément dans Types non spécifiés.Si vous souhaitez les modifier pour faire référence à la nouvelle classe, vous devez traiter chaque attribut ou opération et réinitialiser le type, en sélectionnant la nouvelle classe dans le menu déroulant.

Types multiples

Vous pouvez définir une multiplicité de type d'attribut, d'opération ou encore de paramètre.

Les valeurs autorisées sont les suivantes :

Si la multiplicité est supérieure à 1, vous pouvez également définir les propriétés suivantes :

• IsOrdered - Si la valeur true lui est affectée, la collection présente un ordre défini.

• IsUnique - Si la valeur true lui est affectée, la collection ne contient pas de valeur en double.

Visibilité

La visibilité indique si l'attribut ou l'opération est accessible hors de la définition de classe.Les valeurs autorisées sont les suivantes :

Définition de la signature d'un attribut ou d'une opération

La signature d'un attribut ou d'une opération est une collection de propriétés qui inclut sa visibilité, son nom, ses paramètres (pour les opérations) et son type.

Vous pouvez écrire une signature directement dans le diagramme.Cliquez sur l'attribut ou sur l'opération pour la sélectionner, puis cliquez une nouvelle fois dessus.

Écrivez la signature comme suit :

visibility attribute-name : Type

- ou -

visibility operation-name (parameter1 : Type1, ...) : Type

Par exemple :

+ AddItem (item : MenuItem, quantity : Integer) : Boolean

Utilisez la forme abrégée de visibilité.La valeur par défaut est + (public).

Chaque type peut correspondre à des types que vous avez définis dans le modèle, à des types standard tels qu'Entier ou Chaîne ou encore au nom d'un nouveau type que vous n'avez pas encore défini.

[!REMARQUE]

Si vous écrivez un nom sans un type dans une liste de paramètres, il indique le nom du paramètre plutôt que celui de son type.Dans cet exemple, Élément de menu et Entier deviennent les noms de deux paramètres aux types non spécifiés :

AddItem(MenuItem, Integer) /* parameter names, not types! */

Pour définir la multiplicité d'un type dans une signature, écrivez la multiplicité entre crochets à la suite du nom de type. Par exemple :

+ AddItems (items : MenuItem [1..*])
+ MenuContent : MenuItem [*]

Si l'attribut ou l'opération est statique, son nom apparaîtra souligné dans la signature.Si cela est abstrait, le nom s'affichera alors en italique.

Toutefois, vous pouvez définir uniquement les propriétés Is Static et Is Abstract dans la fenêtre Propriétés.

Signature complète

Lorsque vous modifiez la signature d'un attribut ou d'une opération, certaines propriétés supplémentaires peuvent apparaître à la fin de la ligne et après chaque paramètre.Elles apparaissent entre accolades {…}.Vous pouvez modifier ou ajouter ces propriétés.Par exemple :

+ AddItems (items: MenuItem [1..*] {unique, ordered})
+ GetItems (filter: String) : MenuItem [*] {ordered, query}

Ces propriétés sont les suivantes :

/TotalPrice: Integer

En général, la signature complète apparaît uniquement dans le diagramme pendant que vous le modifiez.Une fois la modification effectuée, les propriétés supplémentaires sont masquées.Si vous souhaitez consulter la signature complète tout le temps, ouvrez le menu contextuel du type, puis choisissez Afficher la signature complète.

Dessin et utilisation d'associations

Utilisez une association pour représenter tout genre de liaison entre deux éléments, indépendamment de la façon dont cette liaison est implémentée dans le logiciel.Par exemple, vous pouvez utiliser une association pour représenter un pointeur en langage C#, une relation dans une base de données ou encore une référence croisée entre deux parties d'un fichier XML.Elle peut représenter une association entre des objets du monde réel, tels que la Terre et le soleil.L'association n'indique pas comment le lien est représenté, mais seulement que les informations existent.

Propriétés d'une association

Après avoir créé une association, définissez-en les propriétés.Ouvrez le menu contextuel de l'association, puis choisissez Propriétés.

En plus de l'ensemble des propriétés de l'association, chaque rôle, autrement dit, chaque fin de l'association, dispose de quelques propriétés qui lui sont propres.Pour les visualiser, développez les propriétés Premier rôle et Second rôle.

Quelques propriétés de chaque rôle sont directement visibles dans le diagramme.Elles se présentent comme suit :

• Nom du rôle.Cette propriété apparaît à la fin appropriée de l'association dans le diagramme.Vous pouvez la définir dans le diagramme ou dans la fenêtre Propriétés.

• Multiplicité, qui a comme valeur par défaut 1.Cette propriété apparaît également dans le diagramme, près de la fin appropriée de l'association.

• Agrégation.Cette propriété apparaît sous la forme d'un diamant, au niveau de l'une des extrémités du connecteur.Vous pouvez l'utiliser pour indiquer que les instances au niveau du rôle d'agrégation possèdent ou contiennent des instances de l'autre.

• Est navigable.Si la valeur true lui est affectée pour un seul rôle, une flèche s'affiche dans la direction navigable.Vous pouvez l'utiliser pour indiquer la navigabilité des liens et des relations de bases de données du logiciel.

Pour obtenir des informations complètes sur ces propriétés et d'autres, consultez Propriétés d'associations dans des diagrammes de classes UML.

Navigabilité

Lorsque vous dessinez une association, celle-ci comporte une flèche à l'extrémité, ce qui signifie que l'association est navigable dans cette direction.Cela est utile si votre diagramme de classes représente des classes logicielles et que les associations représentent des pointeurs ou des références.Cependant, lorsque vous utilisez un diagramme de classes pour représenter des entités et des relations ou des concepts d'entreprise, il est moins approprié pour représenter la navigabilité.Dans ce cas, il est préférable de dessiner des associations sans flèches.Vous pouvez effectuer cette opération en affectant la valeur True à la propriété Est navigable sur les deux extrémités de l'association.Pour simplifier ce processus, vous pouvez télécharger l'exemple de code Modélisation de domaine UML.

Attributs et associations

Une association est une représentation graphique de l'affichage d'un attribut.Par exemple, vous pouvez dessiner une association entre Restaurant et Menu au lieu de créer une classe Restaurant avec un attribut de type Menu.

Chaque nom d'attribut devient un nom de rôle.Il apparaît à l'extrémité opposée de l'association par rapport au type propriétaire.Examinez, par exemple, myMenu dans l'illustration.

En général, il est préférable de n'utiliser des attributs que pour les types que vous ne dessineriez pas dans le diagramme, comme les types primitifs.

Héritage

Utilisez l'outil Héritage pour créer les relations suivantes :

• Relation de généralisation entre un type spécialisé et un type général

  - ou -

• Relation de réalisation entre une classe et une interface qu'il implémente.

Vous ne pouvez pas créer de boucle dans les relations d'héritage.

Généralisation

La généralisation signifie que le type de spécialisation ou dérivé hérite d'attributs, d'opérations et d'associations du type général ou de base.

Le type général apparaît à l'extrémité de la flèche de la relation.

Les opérations et attributs hérités ne sont généralement pas affichés dans les types de spécialisation.Cependant, vous pouvez ajouter des opérations héritées à la liste des opérations du type de spécialisation.Cela est particulièrement utile si vous souhaitez substituer certaines des propriétés d'une opération dans le type de spécialisation, ou encore si vous souhaitez indiquer que le code d'implémentation doit s'en charger.

Pour substituer une définition d'opération dans un type de spécialisation

1. Cliquez sur la relation de généralisation.

   Il est mis en surbrillance, et une balise d'action apparaît près à celui-ci.

2. Cliquez sur la balise d'action, puis sur Remplacer les opérations.

   La boîte de dialogue Remplacer les opérations apparaît alors.

3. Sélectionnez les opérations que vous souhaitez voir apparaître dans le type de spécialisation, puis cliquez sur OK.

Les opérations que vous avez sélectionnées apparaissent à présent dans le type de spécialisation.

Realization

La réalisation signifie qu'une classe implémente les attributs et opérations spécifiés par l'interface.L'interface se situe au niveau de l'embout de flèche du connecteur.

Lorsque vous créez un connecteur de réalisation, les opérations de l'interface sont automatiquement répliquées dans la classe de réalisation.Si vous ajoutez de nouvelles opérations à une interface, elles sont alors répliquées dans ses classes de réalisation.

Après avoir créé une relation de réalisation, vous pouvez la convertir en notation de symbole d'interface.Cliquez avec le bouton droit sur la relation et choisissez Afficher sous forme d'interface Lollipop.

Cela vous permet d'afficher les interfaces qu'une classe implémente, sans encombrer les diagrammes de classes avec des liens de réalisation.Vous pouvez également afficher l'interface et les classes de réalisation dans des diagrammes séparés.

Types de modèles

Vous pouvez définir un type générique ou de modèle qui peut être paramétrable par d'autres types ou valeurs.

Par exemple, vous pouvez créer un dictionnaire générique paramétrable par des types de clés et de valeurs :

Pour créer un type de modèle

1. Créez une classe ou une interface.Celle-ci figurera alors comme votre type de modèle.Nommez-la en conséquence. Par exemple, Dictionary.

2. Ouvrez le menu contextuel du nouveau type, puis choisissez Propriétés.

3. Dans la fenêtre Propriétés, cliquez sur […] dans le champ Paramètres de modèle.

   La boîte de dialogue Éditeur de collections des paramètres de modèle s'affiche.

4. Sélectionnez Ajouter.

5. Affectez un nom de paramètre à la propriété de nom pour votre type de modèle (par exemple, Key).

6. Définissez Genre de paramètre.La valeur par défaut est Classe.

7. Si vous souhaitez que le paramètre accepte uniquement des classes dérivées d'une classe de base particulière, affectez Valeur contrainte à la classe de base de votre choix.

8. Ajoutez autant de paramètres que nécessaire, puis choisissez OK.

9. Ajoutez des attributs et des opérations au type de modèle, comme vous le feriez pour d'autres classes.

   Vous pouvez utiliser des paramètres dont le genre est Classe, Interface ou Énumération dans la définition des attributs et des opérations.Par exemple, vous pouvez définir cette opération dans Dictionary en utilisant des classes de paramètres Key et Value :

   Get(k : Key) : Value

   Vous pouvez utiliser un paramètre dont le genre est Entier comme limite dans une multiplicité.Par exemple, une valeur maximale de paramètre de nombre entier peut être utilisée pour définir la multiplicité d'un attribut sous la forme [0..max].

Après avoir créé des types de modèles, vous pouvez les utiliser pour définir des liaisons de modèles :

Pour utiliser un type de modèle

1. Créez un type (par exemple, AddressTable).

2. Ouvrez le menu contextuel du nouveau type, puis choisissez Propriétés.

3. Dans la propriété Liaison de modèle, sélectionnez le type de modèle (par exemple, Dictionary) dans la liste déroulante.

4. Développez la propriété Liaison de modèle.

   Une ligne apparaît pour chaque paramètre du type de modèle.

5. Affectez une valeur appropriée à chaque paramètre.Par exemple, affectez au paramètre Key une classe appelée Name.

Packages

Vous pouvez visualiser des packages dans un diagramme de classes UML.Un package est un conteneur pour d'autres éléments de modèles.Vous pouvez créer tout élément à l'intérieur d'un package.Dans le diagramme, les éléments se trouvant à l'intérieur du package se déplaceront en même temps que ce dernier.

Vous pouvez utiliser la commande de réduction/développement pour masquer ou afficher le contenu du package.

Consultez Définition de packages et d'espaces de noms..

Le code de génération de diagrammes de classes UML

Pour commencer à implémenter les classes sur un diagramme de classes UML, vous pouvez générer le code C# ou personnaliser des modèles pour la génération de code.Pour démarrer le code de génération à l'aide de les modèles fournis C# :

• Ouvrez le menu contextuel du diagramme ou un élément, choisissez Générer le code, puis définissez les propriétés nécessaires.

  Pour plus d'informations sur la façon de définir ces propriétés et personnaliser des modèles fournis, consultez Comment : générer du code à partir des diagrammes de classes UML.

Voir aussi

Référence

Diagrammes de séquence UML : référence

Concepts

Comment : modifier des modèles et diagrammes UML

Diagrammes de classes UML : référence

Modélisation des besoins des utilisateurs

Diagrammes de composants UML : référence

Diagrammes de cas d'usage UML : référence

Diagrammes de composants UML : référence