Diagrammes de couche : instructions

Vous pouvez décrire l'architecture de votre application à un niveau élevé en créant des diagrammes de couche dans Visual Studio final.Pour vérifier que vos de code demeure cohérent compatibles avec cette conception, valider votre code avec un diagramme de couche dans Visual Studio ultimate ou premium de Visual Studio.Vous pouvez également inclure la validation de couche dans votre processus de génération.Consultez Vidéo de canal la 9 : Conception et valider votre architecture à l'aide de diagrammes de couche.

Qu'est-ce qu'un diagramme de couche ?

À l'instar d'un diagramme d'architecture traditionnel, un diagramme de couche affiche les composants majeurs ou unités fonctionnelles de la conception et leurs interdépendances.Chaque nœud du diagramme, appelé couche, représente un groupe logique d'espaces de noms, de projets ou d'autres artefacts.Vous pouvez dessiner les dépendances qui doivent exister dans votre conception.Contrairement à un diagramme d'architecture traditionnel, vous pouvez vérifier que les dépendances réelles dans le code source sont conformes aux dépendances prévues que vous avez spécifiées.En incluant la validation dans une build normale sur Team Foundation Server, vous pouvez garantir que le code du programme continue à adhérer à l'architecture du système via des modifications futures.Consultez Diagrammes de couche : référence.

Comment concevoir ou mettre à jour votre application avec des diagrammes de couche

La procédure suivante fournit une vue d'ensemble de la manière d'utiliser les diagrammes de couche au sein du processus de développement.Les sections ultérieures de cette rubrique décrivent chaque étape plus en détails.Si vous développez une nouvelle conception, omettez les étapes qui font référence à du code existant.

[!REMARQUE]

Cette procédure est présentée dans un ordre approximatif.Vous voudrez probablement superposer les tâches, les réordonner afin de les adapter à votre propre situation et les reprendre au début de chaque itération dans votre projet.

1. Créez un diagramme de couche pour l'application entière, ou pour une couche à l'intérieur de l'application.

2. Définissez des couches pour représenter les zones et les composants fonctionnels principaux de votre application.Nommez ces couches d'après leur fonction, par exemple, « Présentation » ou « Services ».Si vous avez une solution Visual Studio, vous pouvez associer chaque couche à une collection d'artefacts, tels que des projets, espaces de noms, fichiers, etc.

3. Découvrez les dépendances existantes entre les couches.

4. Modifiez les couches et les dépendances pour afficher la conception mise à jour que vous voulez voir reflétée par le code.

5. Concevez des nouvelles zones de votre application en créant des couches pour représenter les blocs ou les composants architecturaux principaux et définissant des dépendances visant à montrer comment chaque couche utilise les autres.

6. Modifiez la disposition et l'apparence du diagramme pour vous aider à en discuter avec des collègues.

7. Validez le code par rapport au diagramme de couche pour mettre en évidence les conflits entre le code et l'architecture dont vous avez besoin.

8. Mettez à jour le code afin qu'il soit conforme à votre nouvelle architecture.Développez et refactorisez le code de manière itérative jusqu'à ce que la validation n'affiche plus de conflits.

9. Incluez la validation de couche dans le processus de génération pour garantir que le code continue à adhérer à votre conception.

Créez un diagramme de couche

Les diagrammes de couche doivent être créés au sein d'un projet de modélisation.Vous pouvez ajouter un nouveau diagramme de couche à un projet de modélisation existant, créez un projet de modélisation du diagramme de couche, ou copier un diagramme de couche existant dans le même projet de modélisation.

Consultez Créer des diagrammes de couche à partir du code.

Définissez les couches pour représenter des domaines fonctionnels ou des composants

Les couches représentent des groupes logiques d'artefacts, tels que des projets, des fichiers de code, des espaces de noms, des classes ou des méthodes.Vous pouvez créer des couches à partir de artefacts les projets Visual c .NET et Visual Basic .NET, ou vous pouvez joindre des spécifications ou des plans à une couche en joignant des documents, tels que les fichiers Word ou des présentations PowerPoint.Chaque couche apparaît comme un rectangle sur le diagramme et indique le nombre d'artefacts qui lui sont liés.Une couche peut contenir des couches imbriquées qui décrivent des tâches plus granulaires.

En règle générale, les couches doivent être nommées d'après leur fonction, par exemple, « Présentation » ou « Services ».Si les artefacts sont étroitement interdépendants, placez-les dans la même couche.Si les artefacts peuvent être mis à jour séparément ou utilisés dans des applications séparées, placez-les dans des couches différentes.Pour plus d'informations sur la façon de disposer des modèles en couches, consultez le site Patterns & Practices à l'adresse suivante https://go.microsoft.com/fwlink/?LinkId=145794.

Conseil
Il existe certains types d'artefacts que vous pouvez lier aux couches mais qui ne prennent pas en charge la validation par rapport au diagramme de couche.Pour voir si l'artefact prend en charge la validation, ouvrez lExplorateur de couches pour examiner la propriété Prend en charge la validation du lien d'artefact.Consultez l' Gestion des liens entre les couches et les artefacts.

Lorsque vous mettez à jour une application peu familière, vous pouvez utiliser des graphiques de dépendance pour vous aider à explorer et comprendre le code.Ces graphiques peuvent vous aider à découvrir des clusters et des dépendances dans le code.Vous pouvez également utiliser le navigateur de l'architecture pour explorer des espaces de noms et des classes, qui correspondent souvent aux couches existantes.Cela peut vous faciliter l'assignation d'artefacts à des couches.Vous pouvez utiliser ensuite des diagrammes de couche pour vous aider à mettre à jour le code.

Pour plus d'informations, consultez les rubriques suivantes :

• Créer des diagrammes de couche à partir du code

• Visualiser des dépendances de code sur les graphiques de dépendance

• Rechercher du code avec le navigateur de l'architecture

Découvrez les dépendances existantes entre des couches

Une dépendance existe chaque fois qu'un artefact associé à une couche comporte une référence à un artefact associé à une autre couche.Par exemple, une classe dans une couche déclare une variable qui a une classe dans une autre couche.Vous pouvez découvrir les dépendances existantes en leur appliquant une ingénierie à rebours.

[!REMARQUE]

Les dépendances ne peuvent pas faire l'objet d'une ingénierie à rebours pour certains genres d'artefacts.Par exemple, aucune dépendance ne fera l'objet d'une ingénierie à rebours depuis ou vers une couche qui est liée à un fichier texte.Pour identifier les artefacts ayant des dépendances qui peuvent faire l'objet d'une ingénierie à rebours, cliquez avec le bouton droit sur une ou plusieurs couches, puis cliquez sur Afficher les liens.Dans l'Explorateur de couches, examinez la colonne Prend en charge la validation.Les dépendances des artefacts pour lesquels cette colonne affiche la valeur False ne feront pas l'objet d'une ingénierie à rebours.

Pour effectuer une ingénierie à rebours des dépendances existantes entre les couches

• Sélectionnez une ou plusieurs couches, cliquez avec le bouton droit sur une couche sélectionnée, puis cliquez sur Générer des dépendances.

En général, des dépendances qui ne devraient pas exister s'affichent.Vous pouvez modifier ces dépendances pour les ajuster à la conception prévue.

Modifiez les couches et les dépendances pour afficher la conception prévue

Pour décrire les modifications que vous envisagez d'apporter à votre système ou à l'architecture prévue, procédez comme suit pour modifier le diagramme de couche.Vous pouvez également envisager d'apporter des modifications de refactorisation pour améliorer la structure du code avant de l'étendre.Consultez l' Améliorer la structure du code.

Améliorer la structure du code

Les modifications de refactorisation sont des améliorations qui n'affectent pas le comportement de l'application, mais qui permettent de faciliter la modification et l'extension du code à l'avenir.Le code correctement structuré a une conception qu'il est facile de soustraire d'un diagramme de couche.

Par exemple, si vous créez une couche pour chaque espace de noms dans le code et appliquez ensuite une ingénierie à rebours aux dépendances, il doit exister un ensemble minimal de dépendances unidirectionnelles entre les couches.Si vous créez un diagramme plus détaillé à l'aide de classes ou de méthodes pour représenter vos couches, le résultat doit également présenter les mêmes caractéristiques.

Si ce n'est pas le cas, le code sera plus difficile à modifier tout au long de son existence, et il sera moins adapté à la validation à l'aide de diagrammes de couche.

Nouveaux domaines de conception de votre application

Lorsque vous démarrez le développement d'un nouveau projet, ou d'une nouvelle zone dans un nouveau projet, vous pouvez dessiner des couches et des dépendances afin de permettre l'identification des composants majeurs avant de commencer à développer le code.

• Affichez des modèles architecturaux identifiables dans vos diagrammes de couche, si possible.Par exemple, un diagramme de couche qui décrit une application bureautique peut inclure des couches telles que Présentation, Logique de domaine et Magasin de données.Un diagramme de couche qui couvre une fonctionnalité unique dans une application peut avoir des couches telles que Modèle, Affichage et Contrôleur.Pour plus d'informations sur les modèles de ce type, consultez Patterns & Practices: Application Architecture.

  Si vous créez fréquemment des modèles semblables, créez un outil personnalisé.Consultez Comment : définir un élément de boîte à outils de modélisation personnalisé.

• Créez un artefact de code pour chaque couche tel qu'un espace de noms, une classe ou un composant.Cela simplifie le suivi du code, ainsi que la liaison des artefacts de code aux couches.Dès que vous créez chaque artefact, liez-le à la couche appropriée.

• Vous n'avez pas à lier la plupart des classes et les autres artefacts aux couches parce qu'ils font partie d'artefacts plus importants tels que les espaces de noms que vous avez déjà liés aux couches.

• Créez un nouveau diagramme pour une nouvelle fonctionnalité.En général, il y aura un ou plusieurs diagrammes de couche décrivant l'application entière.Si vous concevez une nouvelle fonctionnalité dans l'application, n'ajoutez ni ne modifiez les diagrammes existants.À la place, créez votre propre diagramme qui reflète les nouvelles parties du code.Les couches dans le nouveau diagramme peuvent inclure les couches de présentation, de logique de domaine et de base de données pour la nouvelle fonctionnalité.

  Lorsque vous générez l'application, votre code sera validé à la fois en fonction du diagramme global et de votre diagramme de fonctionnalités détaillé.

Modifiez la disposition pour la présentation et la discussion

Pour vous aider à identifier des couches et des dépendances, ou à les examiner avec les membres de l'équipe, modifiez l'apparence et la disposition du diagramme comme suit :

• Modifiez les tailles, formes et positions des couches.

• Modifiez les couleurs des couches et des dépendances.

  • Sélectionnez une ou plusieurs couches ou dépendances, cliquez avec le bouton droit, puis cliquez sur Propriétés.Dans la fenêtre Propriétés, modifiez la propriété Couleur.

Validez le code par rapport à le diagramme

Lorsque vous avez modifié le diagramme, vous pouvez le valider à manuellement le code à tout moment ou automatiquement chaque fois que vous exécutez une build locale ou Team Foundation Build. 

Reportez-vous à :

• Valider du code avec des diagrammes de couche

• Inclure la validation de couche dans le processus de génération

Mettez à jour le code pour répondre à la nouvelle architecture

En général, des erreurs apparaissent la première fois que vous validez du code par rapport à un diagramme de couche mis à jour.Ces erreurs peuvent avoir plusieurs causes :

• Un artefact est assigné à une couche inappropriée.Dans ce cas, déplacez l'artefact.

• Un artefact, tel qu'une classe, utilise une autre classe d'une manière qui génère un conflit avec votre architecture.Dans ce cas, refactorisez le code pour supprimer la dépendance.

Pour résoudre ces erreurs, mettez à jour le code de façon à ce que la validation ne génère plus d'erreur.Il s'agit généralement d'un processus itératif.Pour plus d'informations sur ces erreurs, consultez Valider du code avec des diagrammes de couche.

[!REMARQUE]

À mesure que vous développez ou refactorisez le code, vous devrez peut-être lier de nouveaux artefacts au diagramme de couche.Toutefois, cette étape peut être superflue, par exemple, lorsque des couches représentent des espaces de noms existants et que le nouveau code ajoute seulement plus de matière à ces espaces de noms.

Pendant le processus de développement, vous pouvez supprimer certains conflits signalés pendant la validation.Par exemple, vous pouvez supprimer des erreurs que vous êtes déjà en train de traiter qui ne sont pas pertinentes dans le cadre de votre scénario spécifique.Lorsque vous supprimez une erreur, il est conseillé d'entrer un élément de travail dans Team Foundation.Pour effectuer cette tâche, consultez Valider du code avec des diagrammes de couche.

Ajoutez la validation de couche dans le processus de génération

Pour vous assurer que les futures modifications apportées au code seront conformes aux diagrammes de couche, ajoutez la validation de couche au processus de génération standard de votre solution.Chaque fois que d'autres membres de l'équipe génèrent la solution, toutes les différences entre les dépendances dans le code et le diagramme de couche seront signalées comme erreurs de build.Pour plus d'informations sur inclure la validation de couche dans le processus de génération, consultez Valider du code avec des diagrammes de couche.

Voir aussi

Concepts

Diagrammes de couche : référence

Créer des diagrammes de couche à partir du code