Diagrammes de couche : instructions

Dans Visual Studio Ultimate, il est possible de décrire la structure d'une application de haut niveau et de vérifier que le code est conforme à cette conception de haut niveau à l'aide des diagrammes de couche. Pour garantir que le code demeure conforme à la conception, vous pouvez inclure la validation de couche dans le cadre du processus de génération.

À 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.

Pour plus d'informations sur les éléments des diagrammes de couche et leurs propriétés, consultez Diagrammes de couche : référence.

Comment concevoir ou mettre à jour votre application à l'aide de 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.

Notes

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éer 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, ou bien créer une modélisation dans votre solution pour le nouveau diagramme de couche.

Pour ajouter un nouveau diagramme de couche à un projet de modélisation

1. Dans le menu Architecture, cliquez sur Nouveau diagramme.

2. Sous Modèles, cliquez sur Diagramme de couche.

3. Attribuez un nom au diagramme.

4. Dans Ajouter au projet de modélisation, recherchez et sélectionnez un projet de modélisation existant dans votre solution.

   ou

   Cliquez sur Créer un nouveau projet de modélisation pour ajouter un nouveau projet de modélisation à la solution.

   Notes

   Le diagramme de couche doit être présent dans un projet de modélisation. Toutefois, vous pouvez le lier à des artefacts situés n'importe où dans la solution.

Vous pouvez également copier un diagramme de couche existant au sein d'un même projet de modélisation.

Notes

En revanche, vous ne pouvez pas ajouter, glisser-déposer ni copier un diagramme de couche existant d'un projet de modélisation à l'autre, ou bien vers un autre emplacement de la solution. Un diagramme de couche copié de cette façon aura les mêmes références que le diagramme d'origine, même si vous le modifiez. Cela entraînera un mauvais fonctionnement de la validation de couche et pourra provoquer d'autres problèmes, tels que des éléments manquants, ou bien provoquer des erreurs lors de la tentative d'ouverture du diagramme.

Pour copier un diagramme de couche, procédez aux étapes suivantes :

Pour copier un diagramme de couche existant

1. Ajoutez un nouveau diagramme de couche au projet de modélisation.

2. Copiez les éléments depuis le diagramme de couche source vers le nouveau diagramme de couche.

Définir des couches pour représenter des zones ou des composants fonctionnels

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 des artefacts de votre solution Visual Studio ou joindre des spécifications ou des plans à une couche en y liant des documents, tels que des 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.

Notes

Certains types d'artefacts peuvent être liés aux couches, mais 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. Pour plus d'informations, consultez la section Gérer les 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 bien 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 :

• Comment : explorer du code avec des graphiques de dépendance

• Comment : rechercher du code à l'aide du navigateur de l'architecture

Utilisez les tâches suivantes pour créer des couches :

Pour	Exécuter ces étapes
Créer une couche pour un artefact unique	Faites glisser l'artefact sur le diagramme de couche de chacune des sources suivantes : Explorateur de solutions Par exemple, vous pouvez faire glisser des fichiers ou des projets. Navigateur de l'architecture Par exemple, vous pouvez faire glisser des espaces de noms, des classes ou des méthodes. Pour plus d'informations, consultez Comment : rechercher du code à l'aide du navigateur de l'architecture. Graphiques de dépendance Pour plus d'informations, consultez Comment : générer des graphiques de dépendance pour le code .NET. Une couche s'affiche sur le diagramme et est liée à l'artefact. Renommez la couche pour refléter les responsabilités du code ou des artefacts associés.
Créer une couche unique pour tous les artefacts sélectionnés	Faites glisser en même temps tous les artefacts sélectionnés vers le diagramme. Une couche s'affiche sur le diagramme et est liée au groupe entier d'artefacts.
Créer une couche pour chaque artefact sélectionné	Appuyez sur la touche MAJ et maintenez-la enfoncée pendant que vous faites glisser simultanément tous les artefacts sur le diagramme de couche. Remarque Si vous utilisez la touche MAJ pour sélectionner une plage d'éléments, relâchez la touche après avoir sélectionné les artefacts.Appuyez de nouveau sur celle-ci et maintenez-la enfoncée lorsque vous faites glisser les artefacts vers le diagramme. Une couche pour chaque artefact s'affiche sur le diagramme et est liée à cet artefact.
Ajouter un artefact à une couche	Faites glisser l'artefact vers la couche.
Créer une couche non liée	Dans la Boîte à outils, développez la section Diagramme de couche, puis faites glisser un élément Couche vers le diagramme de couche. Pour ajouter plusieurs couches, double-cliquez sur l'outil. Lorsque vous avez terminé, cliquez sur l'outil Pointeur ou appuyez sur la touche Échap. - ou - Cliquez avec le bouton droit sur le diagramme de couche, pointez sur Ajouter, puis cliquez sur Couche. Par exemple, vous pouvez procéder ainsi pour représenter une partie de l'application que vous n'avez pas encore commencé à développer. C'est une pratique utile pour créer le code d'espace réservé pour ce type de couches lors d'une phase préliminaire.
Créer des couches imbriquées	Faites glisser une couche existante sur une autre couche. - ou - Cliquez avec le bouton droit sur une couche, pointez sur Ajouter, puis cliquez sur Couche.
Créer une nouvelle couche qui contient deux ou plusieurs couches existantes	Sélectionnez les couches, cliquez avec le bouton droit sur une couche sélectionnée, puis cliquez sur Groupe.
Modifier la couleur d'une couche	Définissez sa propriété Couleur sur la couleur de votre choix.
Spécifier que les artefacts associés à une couche ne peuvent pas dépendre des espaces de noms spécifiés	Tapez les espaces de noms dans la propriété Forbidden Namespace Dependencies (Dépendances d'espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.
Spécifier que les artefacts associés à une couche ne doivent pas appartenir aux espaces de noms spécifiés	Tapez les espaces de noms dans la propriété Forbidden Namespaces (Espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.
Spécifier que les artefacts associés à une couche doivent appartenir à un des espaces de noms spécifiés	Tapez l'espace de noms dans la propriété Required Namespaces (Espace de noms requis) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.

Gestion des liens entre les couches et les artefacts

1. Sur le diagramme de couche, cliquez avec le bouton droit sur une couche, puis cliquez sur Afficher les liens.

   L'Explorateur de couches affiche les artefacts liés à la couche sélectionnée. Pour voir tous les artefacts liés aux couches du diagramme, cliquez sur ce dernier.

2. Utilisez les tâches suivantes pour gérer ces liens :

   Pour	Dans l'Explorateur de couches
   Supprimer le lien entre la couche et un artefact	Cliquez avec le bouton droit sur le lien d'artefact, puis cliquez sur Supprimer.
   Déplacer le lien d'une couche vers une autre	Faites glisser le lien d'artefact vers une couche existante sur le diagramme. - ou - Cliquez avec le bouton droit sur le lien d'artefact, puis cliquez sur Couper. Sur le diagramme de couche, cliquez avec le bouton droit sur la couche, puis cliquez sur Coller.
   Copier le lien d'une couche vers une autre	Cliquez avec le bouton droit sur le lien d'artefact, puis cliquez sur Copier. Sur le diagramme de couche, cliquez avec le bouton droit sur la couche, puis cliquez sur Coller.
   Créer une nouvelle couche à partir d'un lien d'artefact existant	Faites glisser le lien d'artefact vers une zone vide sur le diagramme.
   Vérifiez qu'un artefact lié prend en charge la validation par rapport au diagramme de couche.	Recherchez le lien d'artefact dans la colonne Prend en charge la validation. Les artefacts qui ne prennent pas en charge la validation des diagrammes de couche incluent les projets C++, les sites Web, les documents Office et les fichiers texte brut. Vous pouvez lier de tels artefacts aux couches, mais le processus de validation les ignorera. Aucune erreur de validation n'apparaîtra pour des références à des projets ou à des assemblys qui sont liés à des couches distinctes, lorsqu'aucune dépendance n'apparaît entre ces couches. De telles références ne sont pas considérées comme des dépendances à moins que le code utilise ces références.

Découvrir des dépendances existantes entre des couches

Une dépendance existe partout où un artefact associé à une couche a 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.

Notes

Il n'est pas possible d'appliquer une ingénierie à rebours aux dépendances 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 appliquer une ingénierie à rebours aux dépendances existantes entre des 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 aligner avec la conception prévue.

Modifier 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, vous pouvez modifier le diagramme pour refléter la conception mise à jour. Vous pouvez également envisager d'apporter des modifications de refactorisation pour améliorer la structure du code avant de l'étendre. Pour plus d'informations, consultez Amélioration de la structure du code.

Pour	Exécuter ces étapes
Supprimer une dépendance qui ne doit pas exister	Cliquez sur la dépendance, puis appuyez sur SUPPR.
Changer ou restreindre la direction d'une dépendance	Définissez sa propriété Direction.
Créer de nouvelles dépendances	Utilisez les outils Dépendance et Dépendance bidirectionnelle. Pour dessiner plusieurs dépendances, double-cliquez sur l'outil. Lorsque vous avez terminé, cliquez sur l'outil Pointeur ou appuyez sur la touche Échap.
Spécifier que les artefacts associés à une couche ne peuvent pas dépendre des espaces de noms spécifiés	Tapez les espaces de noms dans la propriété Forbidden Namespace Dependencies (Dépendances d'espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.
Spécifier que les artefacts associés à une couche ne doivent pas appartenir aux espaces de noms spécifiés	Tapez les espaces de noms dans la propriété Forbidden Namespaces (Espaces de noms interdits) de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.
Spécifier que les artefacts associés à une couche doivent appartenir à un des espaces de noms spécifiés	Tapez l'espace de noms dans la propriété Espace de noms requis de la couche. Utilisez un point-virgule (;) pour séparer les espaces de noms.

Amélioration de 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.

Concevoir des nouvelles zones 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é. Pour plus d'informations, 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é.

Modifier la disposition pour la présentation et la discussion

Pour vous aider à identifier les couches et les dépendances ou à en discuter avec les membres de l'équipe, modifiez l'apparence et la disposition du diagramme des façons suivantes :

• modifier les tailles, formes et positions des couches ;

• modifier 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.

Valider le code par rapport au diagramme

Une fois que vous avez modifié le diagramme, vous pouvez le valider à tout moment manuellement par rapport au code ou automatiquement chaque fois que vous exécutez une build locale. Vous pouvez également exécuter automatiquement la validation à chaque génération effectuée à l'aide de Team Foundation Server.

Pour plus d'informations, consultez :

• Comment : valider du code .NET par rapport à des diagrammes de couche

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

Pour ajouter manuellement des assemblys ou des projets pour la validation

1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet de modélisation ou sur le dossier Références de couche, puis cliquez sur Ajouter une référence.

2. Dans la boîte de dialogue Ajouter une référence, sélectionnez les assemblys ou les projets, puis cliquez sur OK.

Pour valider manuellement du code à partir d'un diagramme de couche ouvert

1. Cliquez avec le bouton droit sur la surface de diagramme, puis cliquez sur Valider l'architecture.

   Notes

   Par défaut, la propriété Action de génération sur le fichier de diagramme de couche (.layerdiagram) a la valeur Valider afin que le diagramme soit inclus dans le processus de validation.

   La fenêtre Liste d'erreurs signale toutes les erreurs qui se produisent. Pour plus d'informations sur les erreurs de validation, consultez Présentation des erreurs de validation de couche.

2. Pour afficher la source de chaque erreur, double-cliquez sur l'erreur dans la fenêtre Liste d'erreurs.

   Notes

   Visual Studio peut afficher un graphique de dépendance à la place de la source de l'erreur. Cela se produit lorsque le code a une dépendance sur un assembly qui n'est pas spécifié par le diagramme de couche ou lorsqu'une dépendance spécifiée par le diagramme de couche manque dans le code. Examinez le graphique de dépendance ou le code pour déterminer si la dépendance doit exister. Pour plus d'informations sur les graphiques de dépendance, consultez Comment : parcourir des documents de graphique et y accéder.

3. Pour gérer les erreurs, consultez Mettre à jour le code afin qu'il soit conforme à la nouvelle architecture.

Pour valider le code manuellement à partir de l'invite de commandes

1. Ouvrez l'invite de commandes Visual Studio.

   Pour ouvrir l'invite de commandes, cliquez sur Démarrer, pointez sur Tous les programmes, Microsoft Visual Studio 2010, Visual Studio Tools, puis cliquez sur Invite de commandes de Visual Studio 2010.

2. Choisissez l'une des valeurs suivantes :

   • Pour valider le code par rapport à un projet de modélisation spécifique dans la solution, exécutez MSBuild avec la propriété personnalisée ci-dessous.

     msbuild <FilePath+ModelProjectFileName>.modelproj
     /p:ValidateArchitecture=true
     

     - ou -

     Accédez au dossier qui contient le fichier du projet de modélisation (.modelproj) et le diagramme de couche, puis exécutez MSBuild avec la propriété personnalisée suivante :

     msbuild /p:ValidateArchitecture=true 
     

   • Pour valider le code par rapport à tous les projets de modélisation dans la solution, exécutez MSBuild avec la propriété personnalisée suivante :

     msbuild <FilePath+SolutionName>.sln /p:ValidateArchitecture=true 
     

     - ou -

     Accédez au dossier de solution, qui doit contenir un projet de modélisation contenant un diagramme de couche, puis exécutez MSBuild avec la propriété personnalisée suivante :

     msbuild /p:ValidateArchitecture=true
     

   Toutes les erreurs qui ont lieu seront répertoriées. Pour plus d'informations sur MSBuild, consultez MSBuild et MSBuild, tâche.

Pour plus d'informations sur la compréhension des erreurs de validation, consultez Présentation des erreurs de validation de couche.

Pour valider le code automatiquement à partir d'une build locale

• Utilisez un éditeur de texte pour ouvrir le fichier projet de modélisation (.modelproj), puis y inclure la propriété suivante :

<ValidateArchitecture>true</ValidateArchitecture>

- ou -

1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet de modélisation qui contient le ou les diagrammes de couche, puis cliquez sur Propriétés.

2. Dans la fenêtre Propriétés, affectez à la propriété Valider l'architecture du projet de modélisation la valeur True.

   Cela inclut le projet de modélisation dans le processus de validation.

3. Dans l'Explorateur de solutions, cliquez sur le fichier du diagramme de couche (.layerdiagram) que vous voulez utiliser pour la validation.

4. Dans la fenêtre Propriétés, assurez-vous que la propriété Action de génération du diagramme a la valeur Valider.

   Cela inclut le diagramme de couche dans le processus de validation.

Pour plus d'informations sur la compréhension des erreurs de validation, consultez Présentation des erreurs de validation de couche. Pour gérer les erreurs, consultez Mettre à jour le code afin qu'il soit conforme à la nouvelle architecture.

Mettre à jour le code afin qu'il soit conforme à 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 incorrecte. 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 jusqu'à ce qu'aucune erreur n'apparaisse plus pendant la validation. Il s'agit généralement d'un processus itératif.

Notes

À 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 créer un élément de travail pour une erreur de validation

• Dans la fenêtre Liste d'erreurs, cliquez avec le bouton droit sur l'erreur, pointez sur Créer un élément de travail, puis cliquez sur le type d'élément de travail que vous voulez créer.

Utilisez les tâches suivantes pour gérer les erreurs de validation dans la fenêtre Liste d'erreurs :

Pour	Procédez comme suit
Supprimer des erreurs sélectionnées pendant la validation	Cliquez avec le bouton droit sur une ou plusieurs erreurs sélectionnées, pointez sur Gérer les erreurs de validation, puis cliquez sur Supprimer les erreurs. Les erreurs supprimées apparaissent barrées. Lors de la prochaine validation, ces erreurs ne s'afficheront pas. Les erreurs supprimées sont suivies dans un fichier .suppressions pour le fichier de diagramme de couche correspondant.
Cesser de supprimer des erreurs sélectionnées	Cliquez avec le bouton droit sur la ou les erreurs supprimées sélectionnées, pointez sur Gérer les erreurs de validation, puis cliquez sur Arrêter la suppression des erreurs. Les erreurs supprimées qui sont sélectionnées s'afficheront lors de la prochaine validation.
Restaurer toutes les erreurs supprimées dans la fenêtre Liste d'erreurs	Cliquez avec le bouton droit n'importe où dans la fenêtre Liste d'erreurs, pointez sur Gérer les erreurs de validation, puis cliquez sur Afficher les erreurs supprimées.
Masquer toutes les erreurs supprimées de la fenêtre Liste d'erreurs	Cliquez avec le bouton droit n'importe où dans la fenêtre Liste d'erreurs, pointez sur Gérer les erreurs de validation, puis cliquez sur Masquer les erreurs supprimées.

Inclure 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 valider le code lorsque vous exécutez Team Foundation Build

1. Dans Team Explorer, double-cliquez sur la définition de build, puis sur Processus.

2. Sous Paramètres du processus de génération, développez Compilation, puis tapez le texte suivant dans le paramètre Arguments MSBuild :

   /p: ValidateArchitecture=true

Pour plus d'informations, consultez Définir une build à l'aide du modèle par défaut.

Voir aussi

Tâches

Comment : créer des diagrammes de couche à partir d'artefacts

Comment : valider du code .NET par rapport à des diagrammes de couche

Concepts

Diagrammes de couche : référence