Générer du code à partir de diagrammes de classes UML

Pour générer du code Visual C# .NET à partir de diagrammes de classes UML dans Visual Studio Ultimate, utilisez la commande Générer le code. Par défaut, la commande génère un type C# pour chaque type UML que vous sélectionnez. Vous pouvez modifier et étendre ce comportement en modifiant ou en copiant les modèles de texte qui génèrent le code. Vous pouvez spécifier un comportement distinct pour les types contenus dans les différents packages de votre modèle.

La commande Generate Code est particulièrement adaptée à la génération de code à partir de la sélection d'éléments de l'utilisateur, et à la génération d'un fichier pour chaque classe UML ou autre élément. Par exemple, la capture d'écran présente deux fichiers C# générés à partir de deux classes UML.

Si, en revanche, vous voulez générer du code dans lequel les fichiers générés n'ont pas de relation 1:1 avec les éléments UML, vous pouvez envisager d'écrire des modèles de texte appelés avec la commande Transformer tous les modèles. Pour plus d'informations sur cette méthode, consultez Comment : générer des fichiers à partir d'un modèle UML.

Pour plus d'informations sur les diagrammes de classes UML dans Visual Studio Ultimate, consultez les rubriques suivantes :

• Diagrammes de classes UML : référence

• Diagrammes de classes UML : indications

Utilisation de la commande Generate Code

La procédure suivante décrit le comportement par défaut de la commande Generate Code :

Pour générer un fichier séparé pour chaque élément

1. Créez un modèle UML qui contient des classes. Vous pouvez appliquer des stéréotypes aux éléments de modèle.

   Pour plus d'informations, consultez Transformations de génération de code par défaut.

2. Sur un diagramme de classes ou dans l'Explorateur de modèles UML, sélectionnez les éléments à partir desquels vous voulez générer le code. Vous pouvez sélectionner l'un des éléments suivants :

   • Un ensemble spécifique d'éléments.

   • Un package ou le modèle, pour générer le code à partir de son contenu.

   • Le diagramme, pour en sélectionner tous les éléments.

3. Ouvrez le menu contextuel pour un élément sélectionné, puis choisissez Générer le code.

   La première fois que vous utilisez la commande Generate Code dans un modèle particulier, une boîte de dialogue s'affiche. Cette boîte de dialogue vous permet de modifier les paramètres de génération de code du modèle.

   Choisissez OK, sauf si vous voulez modifier ces paramètres.

   Pour retourner ultérieurement à cette boîte de dialogue, ouvrez le menu contextuel du diagramme, puis choisissez Configurer les paramètres de génération de code par défaut. Pour plus d'informations, consultez Personnalisation de la commande Generate Code.

Les fichiers qui contiennent le code C# sont générés. Dans le cas par défaut, un fichier est généré pour chaque type, et les fichiers sont générés dans un projet de bibliothèque de classes C#. Vous pouvez toutefois personnaliser ce comportement. Pour plus d'informations, consultez Personnalisation de la commande Generate Code.

Certains tests de validation sont appliqués au modèle pour vérifier qu'il peut être traduit en C#. Si ces tests échouent, un message d'erreur est affiché et la génération de code n'est pas exécutée. Si vous avez créé une commande de menu de validation, le code n'est pas généré pour tout élément pour lequel votre commande de validation échoue. Pour plus d'informations, consultez Comment : définir des contraintes de validation pour les modèles UML.

Transformations de génération de code par défaut

Cette section résume les résultats produits par la commande Generate Code, sauf si vous personnalisez la commande. Pour plus d'informations, consultez Personnalisation de la commande Generate Code.

• Un type C# est produit pour chaque type que vous avez sélectionné dans le modèle UML. Chaque type est placé dans un fichier de code séparé dans le dossier GeneratedCode.

• Si le type UML est contenu dans un package, le type C# généré est placé à l'intérieur d'un espace de noms et le fichier est généré dans un dossier portant le même nom que l'espace de noms.

• Une propriété C# est générée pour chaque Attribute d'une classe UML.

• Une méthode C# est générée pour chaque Operation d'un type UML.

• Un champ C# est généré pour chaque association navigable à laquelle la classe participe.

En ajoutant un stéréotype à chaque type UML, vous pouvez contrôler un plus grand nombre de propriétés du type C# généré.

Pour créer ce type C#	Dessiner ce type UML	Appliquer ce stéréotype
Classe	Classe	<aucun> ou C# class
Interface	Interface	<aucun> ou C# interface
Énumération	Énumération	<aucun> ou C# enum
Délégué	Classe	C# delegate
Struct	Classe	C# struct

Pour définir un stéréotype sur un type ou un autre élément

1. Ouvrez le menu contextuel de l'élément sur un diagramme ou dans l'Explorateur de modèles UML, puis choisissez Propriétés.

2. Dans la fenêtre Propriétés, choisissez la flèche déroulante vers le bas dans la propriété Stéréotypes, puis activez la case à cocher pour le stéréotype que vous voulez appliquer.

   Conseil

   Si les stéréotypes C# ne s'affichent pas, activez le profil C# pour le modèle ou pour un package qui contient les éléments de modèle auxquels vous vous intéressez.Sélectionnez le package ou la racine du modèle dans l'Explorateur de modèles UML.Ensuite, dans la fenêtre Propriétés, choisissez Profil, puis activez le profil C#.

3. Développez la propriété Stéréotypes pour voir les propriétés supplémentaires que vous pouvez définir.

Les propriétés Description de types, d'attributs, d'opérations et d'associations sont écrites dans les commentaires <summary> dans le code généré. Les éléments de commentaire liés aux types sont écrits dans les commentaires <remarks>.

Variation du code généré

Le code généré varie en fonction des propriétés de chaque type, attribut ou opération. Par exemple, si vous affectez à la propriété Is Abstract d'une classe la valeur true, le mot clé abstract s'affichera sur la classe générée. Si vous affectez à la propriété Multiplicité d'un attribut la valeur 0..*, le type de la propriété générée sera IEnumerable<>.

De plus, chaque stéréotype fournit plusieurs propriétés supplémentaires que vous pouvez définir. Ces valeurs sont traduites en mots clés appropriés dans le code C#. Par exemple, si vous définissez la propriété Is Static sur une classe, la classe C# sera static.

Pour définir ces propriétés supplémentaires, sélectionnez la classe ou un autre élément dans le diagramme. Dans la fenêtre Propriétés, développez Stéréotypes, puis développez le stéréotype C#, tel que Classe C#. Pour les classes, ces propriétés supplémentaires incluent :

• CLR Attributes

• Is Partial

• Is Static

• Is Unsafe

• Package Visibility

Chaque attribut et opération dispose également de propriétés de stéréotype que vous pouvez définir. Si vous ne voyez pas les propriétés sur un nouvel attribut, exécutez la commande Generate Code.

Personnalisation de la commande Generate Code

La commande Generate Code transforme vos éléments de modèle à l'aide d'un ensemble de modèles de texte. Pour plus d'informations sur les modèles de texte, consultez Génération de code et modèles de texte T4.

Les modèles sont spécifiés dans un ensemble de liaisons de modèles de texte. Une liaison de modèle de texte spécifie quel modèle doit être appliqué, où la sortie générée doit être placée, ainsi que d'autres paramètres de la commande Generate Code.

Lorsque vous exécutez pour la première fois la commande Generate Code sur un modèle particulier, elle joint un ensemble par défaut de liaisons de modèles à la racine du modèle. Ces liaisons s'appliquent à tous les éléments du modèle.

Toutefois, vous pouvez effectuer des substitutions et des ajouts pour ces liaisons par défaut, en joignant vos propres liaisons à des packages, des classes ou d'autres éléments. Une liaison s'applique à tous les éléments contenus dans l'élément auquel elle est jointe. Par exemple, si vous voulez que tous les types d'un package particulier soient transformés par un ensemble de modèles différent ou soient sortis dans un dossier distinct, vous pouvez joindre des liaisons de modèles au package.

Pour inspecter les liaisons de modèles jointes à un élément de modèle, choisissez les points de suspension [...] dans la propriété Liaisons de modèles de texte dans la fenêtre Propriétés.

La commande Generate Code applique des modèles à chaque élément de modèle que vous avez sélectionné. Pour chaque élément, l'ensemble de modèles appliqué est l'ensemble combiné des modèles joints à ses conteneurs, jusqu'à la racine du modèle incluse.

Si deux liaisons de modèles dans cet ensemble ont le même nom, la liaison dans le plus petit conteneur substitue celle dans le plus grand conteneur. Par exemple, la racine modèle a une liaison avec le nom Class Template. Pour que votre propre modèle soit appliqué au contenu d'un package particulier, définissez votre liaison de modèle avec le nom Class Template.

Plusieurs modèles peuvent être appliqués à un élément de modèle. Vous pouvez générer plusieurs fichiers à partir de chaque élément de modèle.

Notes

Les liaisons jointes à la racine du modèle agissent comme des valeurs par défaut pour tous les éléments du modèle.Pour afficher ces liaisons par défaut, ouvrez le menu contextuel de la surface de diagramme, puis choisissez Configurer les paramètres de génération de code par défaut.Vous pouvez également sélectionner la racine du modèle dans l'Explorateur de modèles UML, puis choisir [...] dans la propriété Liaisons de modèles de texte.Les liaisons ne s'affichent pas tant que vous n'avez pas utilisé la commande Generate Code au moins une fois.Les liaisons de modèles ne peuvent pas être jointes à un diagramme.

Pour joindre des liaisons de modèles de texte à un package ou à un autre élément de modèle

1. Dans Explorateur de modèles UML, ouvrez le menu contextuel pour un élément de modèle, puis choisissez Propriétés. En général, vous joignez des liaisons de modèles de texte à un package ou à la racine du modèle.

2. Dans la fenêtre Propriétés, choisissez le bouton de sélection ([...]) dans la propriété Liaisons de modèles de texte.

   La boîte de dialogue Liaisons de modèles de texte s'affiche.

3. Choisissez Ajouter pour créer une liaison de modèle de texte.

   ou

   choisissez une liaison existante pour la modifier.

   Chaque liaison de modèle définit la manière dont un modèle spécifié doit être appliqué à l'élément de modèle que vous avez sélectionné, et aux autres éléments de modèle qu'il contient.

4. Dans la boîte de dialogue, définissez les propriétés de la liaison de modèle de texte.

   Propriété	Description
   Nom	Nom pour cette liaison. Pour substituer une liaison héritée d'un modèle ou d'un package contenant, utilisez le même nom que la liaison à substituer.
   Overwrite	Si la valeur est true, tout code existant est remplacé.
   Nom de la cible	Nom du fichier généré. Vous pouvez insérer des expressions dans cette chaîne, telles que {Nom} ou {Nom.Propriétaire}. Par exemple, vous pouvez écrire : {Nom.Propriétaire}_{Nom}. L'expression est évaluée sur l'élément de modèle. Elle peut utiliser des propriétés d'éléments, mais pas de méthodes. Pour trouver les propriétés pouvant être utilisées, recherchez les propriétés de types dans Microsoft.VisualStudio.Uml.*. Important L'expression {Nom} ou {Nom.Propriétaire} ne peut être utilisée que dans la propriété Target Name.Pour modifier le nom de la classe générée, vous devez modifier le modèle.Pour plus d'informations, consultez Écriture d'un modèle de texte.
   Chemin d'accès au projet	Spécifie le chemin d'accès au projet Visual Studio qui contiendra les fichiers de sortie de la transformation. Utilisez des valeurs typées pour créer un projet. Choisissez le bouton de sélection ([...]) pour sélectionner un projet existant. Un projet est créé s'il n'existe pas. Il s'agit d'un projet de bibliothèque de classes C#. Pour ce faire, vous devez taper le projet directement. Vous pouvez inclure des macros de variables d'environnement telles que %ProgramFiles% ou %LocalAppData%.
   Répertoire cible	Dossier dans lequel le fichier cible est généré. Le chemin d'accès est relatif au dossier du projet. Vous pouvez utiliser l'expression {PackageStructure} pour insérer un chemin d'accès qui correspond aux noms des packages contenants. La valeur par défaut est \GeneratedCode\{PackageStructure}. Vous pouvez également inclure des variables d'environnement telles que %TEMP% ou %HomePath%. > [!IMPORTANT] > <P>{PackageStructure} peut être utilisé uniquement dans la propriété <STRONG>Target Directory</STRONG>.</P>
   Chemin d'accès au fichier de modèle	Modèle qui exécutera la transformation. Vous pouvez utiliser les modèles fournis ou créer le vôtre. Les modèles fournis se trouvent à l'emplacement suivant : …\Program Files\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\

   5. Vous pouvez joindre à un élément le nombre de liaisons de votre choix.

   Écriture d'un modèle de texte

   Vous pouvez écrire vos propres modèles de texte. Les modèles de texte peuvent générer un code programme ou tout autre type de fichier texte.

   Nous vous recommandons de commencer par modifier des copies des modèles standard. Vous pouvez copier les modèles à partir des emplacements suivants :

   …\Program Files\Microsoft Visual Studio 12.0\Common7\IDE\Extensions\Microsoft\Architecture Tools\Extensibility\Templates\Text\

   Pour comprendre les modèles de texte, reportez-vous aux rubriques suivantes.

   • Un modèle de texte est un prototype du fichier résultant et contient à la fois le texte résultant et le code de programme qui lit le modèle. Pour plus d'informations, consultez Génération de code et modèles de texte T4.

   • Pour naviguer dans le modèle UML dans le code de programme, vous devez utiliser l'API UML. Pour plus d’informations, consultez Comment : naviguer dans le modèle UML et Référence des API pour l'extensibilité de la modélisation UML.

   Pour utiliser les modèles avec la commande Generate Code, vous devez inclure la directive de modélisation. Par exemple :

   <#@ Modeling ElementType="Microsoft.VisualStudio.Uml.Classes.IClass" Processor="ModelingProcessor" #>

   L'attribut ElementType définit le type d'élément UML auquel ce modèle s'applique.

   Dans le modèle, this appartient à une classe temporaire qui a les propriétés suivantes :

   • Element = IElement UML auquel le modèle est appliqué.

   • Errors: CompilerErrorCollection

   • Host: ITextTemplatingEngineHost

   • ModelBus: ModelBus. Pour plus d'informations, consultez Comment : intégrer des modèles UML à d'autres modèles et outils.

   • ProfileName = "C#Profile"

   • ServiceProvider: IServiceProvider

   • Session: TextTemplatingSession.

   • Store: Store. Il s'agit du Magasin du kit de développement logiciel Visualization and Modeling SDK sur lequel ModelStore UML est implémenté. Pour obtenir le IModelStore UML, utilisez this.Element.GetModelStore().

   Les points suivants peuvent vous être utiles lorsque vous écrivez un modèle de texte. Ces informations sont décrites en détail dans Génération de code et modèles de texte T4.

   • Vous pouvez définir l'extension de nom de fichier du résultat dans la directive Output. Une directive Output est obligatoire dans chaque modèle de texte.

   • Certains assemblys sont référencés automatiquement par le modèle. Ces assemblys incluent par exemple System.dll et Microsoft.VisualStudio.Uml.Interfaces.dll.

     Pour utiliser d'autres assemblys dans votre code de programme de génération, vous devez utiliser une directive Assembly. Par exemple :

     <#@ Assembly Name="%ProgramFiles%\Microsoft Visual Studio 12.0\Common7\IDE\PublicAssemblies\Microsoft.VisualStudio.ArchitectureTools.Extensibility.dll" #>

   • Certains espaces de noms tels que System sont importés automatiquement dans votre code de programme. Pour d'autres espaces de noms, vous pouvez utiliser la directive Import de la même manière que vous utiliseriez une instruction using. Par exemple :

     <#@ Import Namespace="Microsoft.VisualStudio.Uml.Classes" #>

     <#@ Import Namespace="Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml" #>

   • Utilisez la directive Include pour référencer le texte d'un autre fichier.

   • Les parties du modèle placées entre crochets <# ... #> sont exécutées par la commande Generate Code. Les parties du modèle à l'extérieur de ces crochets sont copiées vers le fichier de résultats. Il est important de distinguer le code de génération et le texte généré. Le texte peut être généré dans n'importe quel langage.

   • <#= Expressions #> sont évaluées et converties en chaînes.

   Voir aussi

   Concepts

   Diagrammes de classes UML : référence

   Diagrammes de classes UML : indications

   Comment : générer des fichiers à partir d'un modèle UML