Ajout d'une validation d'architecture personnalisée aux diagrammes de couche

Article
03/12/2013

Dans Visual Studio Ultimate et Visual Studio Premium, les utilisateurs peuvent valider le code source dans un projet Visual Studio par rapport à un modèle de couche pour pouvoir vérifier que le code source est conforme aux dépendances sur un diagramme de couche.Il existe un algorithme de validation standard, mais vous pouvez définir vos propres extensions de validation pour Visual Studio Ultimate et Visual Studio Premium.

Lorsque l'utilisateur sélectionne la commande Validate Architecture sur un diagramme de couche, la méthode de validation standard est appelée, suivie par toutes extensions de validation installées.

[!REMARQUE]

La validation dans un diagramme de couche n'est pas la même que la validation dans les diagrammes UML.Dans un diagramme de couche, le but principal est de comparer le diagramme avec le code de programme dans d'autres parties de la solution.

Vous pouvez empaqueter votre extension de validation de couche dans une extension d'intégration Visual Studio (VSIX) et la distribuer à d'autres utilisateurs Visual Studio Ultimate.Vous pouvez placer votre validateur seul dans un projet VSIX ou le combiner dans le même projet VSIX que d'autres extensions.Vous devez écrire le code du validateur dans son propre projet Visual Studio, pas dans le même projet que d'autres extensions.

Attention
Après avoir créé un projet de validation, copiez exemple de code à la fin de cette rubrique puis modifiez -la dans vos propres besoins.

Configuration requise

Visual Studio Ultimate
SDK de Visual Studio
Kit de développement logiciel de visualisation et de modélisation de Visual Studio

Définition d'un validateur de couche dans un nouveau projet VSIX

La méthode la plus rapide pour créer un validateur consiste à utiliser le modèle de projet.Cela place le code et le manifeste VSIX dans le même projet.

Pour définir une extension à l'aide d'un modèle de projet

Créez un projet dans une nouvelle solution, en utilisant la commande Nouveau projet dans le menu Fichier.

Dans la boîte de dialogue Nouveau projet, sous Projets de modélisation, sélectionnez Layer Designer Validation Extension (Extension de validation de concepteur de couche).

Le modèle crée un projet qui contient un petit exemple.

Attention
Pour faire fonctionner le modèle correctement : Appels de modification à LogValidationError pour supprimer les arguments facultatifs errorSourceNodes et errorTargetNodes. Si vous utilisez des propriétés, appliquez la mise à jour mentionnée dans Ajout de propriétés personnalisées à un diagramme de couche.De plus, l'architecture ouverte avant que vous avez ouvert une solution de modèle.

Pour faire fonctionner le modèle correctement :

Appels de modification à LogValidationError pour supprimer les arguments facultatifs errorSourceNodes et errorTargetNodes.
Si vous utilisez des propriétés, appliquez la mise à jour mentionnée dans Ajout de propriétés personnalisées à un diagramme de couche.De plus, l'architecture ouverte avant que vous avez ouvert une solution de modèle.

Modifiez le code pour définir votre validation.Pour plus d'informations, consultez Programmation de la validation.
Pour tester l'extension, consultez Débogage de la validation de couche.

[!REMARQUE]

Votre méthode sera appelée uniquement dans des circonstances spécifiques, et les points d'arrêt ne fonctionneront pas automatiquement.Pour plus d'informations, consultez Débogage de la validation de couche.
Pour installer l'extension dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans bin\*.Copiez-le sur l'ordinateur sur lequel vous souhaitez l'installer, puis double-cliquez dessus.Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.

Ajout d'un validateur de couche à un projet VSIX séparé

Si vous souhaitez créer un VSIX qui contient des validateurs de couche, des commandes et d'autres extensions, nous vous recommandons de créer un projet pour définir le VSIX et des projets séparés pour les gestionnaires.Pour plus d'informations sur les autres types d'extensions de modélisation, consultez l'article Extension de modèles et de diagrammes UML.

Pour ajouter la validation de couche à un VSIX séparé

Créez un projet de bibliothèque de classes dans une solution Visual Studio Ultimate nouvelle ou existante.Dans la boîte de dialogue Nouveau projet, cliquez sur Visual C#, puis sur Bibliothèque de classes.Ce projet contiendra la classe de validation de couche.
Identifiez ou créez un projet VSIX dans votre solution.Un projet VSIX contient un fichier nommé source.extension.vsixmanifest.Si vous devez ajouter un projet VSIX, suivez ces étapes :
1. Dans la boîte de dialogue Nouveau projet, choisissez Visual C#, Extensibilité, Projet VSIX.
2. Dans Explorateur de solutions, dans le menu contextuel du projet VSIX, Définir comme projet de démarrage.
Dans source.extension.vsixmanifest, sous Ressources, ajoutez le projet de validation de couche en tant que composant MEF :
1. Sélectionnez Nouveau.
2. Dans la boîte de dialogue Ajouter un nouveau composant, définissez :
  
  Type = Microsoft.VisualStudio.MefComponent
  
  Source = Projet dans la solution actuelle
  
  Projet = votre projet de validation
Vous devez également l'ajouter comme validation de couche :
1. Sélectionnez Nouveau.
2. Dans la boîte de dialogue Ajouter un nouveau composant, définissez :
  
  Type = Microsoft.VisualStudio.ArchitectureTools.Layer.Validator.Ce n'est pas l'une des options dans la liste déroulante.Vous devez la déplacer dans le clavier.
  
  Source = Projet dans la solution actuelle
  
  Projet = votre projet de validation

Revenez au projet de validation de couche et ajoutez les références de projet suivantes :

Référence	Actions autorisées
Microsoft.VisualStudio.GraphModel.dll	Lire le graphique d'architecture
Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema.dll	Lire le code DOM associé aux couches
Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll	Lire le modèle de couche
Microsoft.VisualStudio.ArchitectureTools.Extensibility	Lire et mettre à jour les formes et les diagrammes
System.ComponentModel.Composition	Définir le composant de validation à l'aide de Managed Extensibility Framework (MEF)
Microsoft.VisualStudio.Modeling.Sdk.11.0	Définir des extensions de modélisation

Copiez l'exemple de code à la fin de cette rubrique dans le fichier de classe dans le projet de bibliothèque de validateur de contenir le code de votre validation.Pour plus d'informations, consultez Programmation de la validation.
Pour tester l'extension, consultez Débogage de la validation de couche.

[!REMARQUE]

Votre méthode sera appelée uniquement dans des circonstances spécifiques, et les points d'arrêt ne fonctionneront pas automatiquement.Pour plus d'informations, consultez Débogage de la validation de couche.
Pour installer le VSIX dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans le répertoire bin du projet VSIX.Copiez-le sur l'ordinateur sur lequel vous souhaitez installer le VSIX.Double-cliquez sur le fichier VSIX dans l'Explorateur Windows.(L'Explorateur de fichiers dans windows 8.)

Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.

Programmation de la validation

Pour définir une extension de validation de couche, définissez une classe avec les caractéristiques suivantes :

La forme générale de la déclaration se présente comme suit :


using System.ComponentModel.Composition;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.GraphModel;
...
 [Export(typeof(IValidateArchitectureExtension))]
  public partial class Validator1Extension :
                  IValidateArchitectureExtension
  {
    public void ValidateArchitecture(Graph graph)
    {
       GraphSchema schema = graph.DocumentSchema;
      ...
  } }

Lorsque vous découvrez une erreur, vous pouvez la signaler à l'aide de LogValidationError().

Attention

N'utilisez pas les paramètres optionnels d' LogValidationError.

Attention
N'utilisez pas les paramètres optionnels d' LogValidationError.

Lorsque l'utilisateur appelle la commande de menu Valider l'architecture, le système runtime de couche analyse les couches et leurs artefacts pour produire un graphique.Le graphique se compose de quatre parties :

Les modèles de couche de la solution Visual Studio représentés comme des nœuds et des liens dans le graphique.
Le code, les éléments de projet et d'autres artefacts qui sont définis dans la solution et sont représentés comme des nœuds, et les liens qui représentent les dépendances découvertes par le processus d'analyse.
Les liens des nœuds de couche vers les nœuds d'artefact de code.
Les nœuds qui représentent des erreurs découvertes par le validateur.

Une fois le graphique construit, la méthode de validation standard est appelée.Lorsqu'elle se termine, toutes les méthodes de validation d'extension installées sont appelées dans un ordre non spécifié.Le graphique est passé à chaque méthode ValidateArchitecture, qui peut l'analyser et signaler toutes les erreurs qu'elle rencontre.

[!REMARQUE]

Cette opération diffère du processus de validation appliqué aux diagrammes UML et du processus de validation qui peut être utilisé dans des langages spécifiques à un domaine.

Les méthodes de validation ne doivent pas modifier le modèle de couche ou le code validé.

Le modèle de graphique est défini dans Microsoft.VisualStudio.GraphModel.Ses classes principales sont GraphNode et GraphLink.

Chaque nœud et chaque lien a une ou plusieurs catégories qui spécifient le type d'élément ou de relation qu'il représente.Les nœuds d'un graphique typique ont les catégories suivantes :

Dsl.LayerModel
Dsl.Layer
Dsl.Reference
CodeSchema_Type
CodeSchema_Namespace
CodeSchema_Type
CodeSchema_Method
CodeSchema_Field
CodeSchema_Property

Les liens des couches vers les éléments dans le code ont la catégorie « Représente ».

Débogage de la validation

Pour déboguer votre extension de validation de couche, appuyez sur CTRL+F5.Une instance expérimentale de Visual Studio s'ouvre alors.Dans cette instance, ouvrez ou créez un modèle de couche.Ce modèle doit être associé au code et doit avoir au moins une dépendance.

Test avec une solution qui contient des dépendances

La validation n'est exécutée que si les caractéristiques suivantes sont présentes :

Il existe au moins un lien de dépendance sur le diagramme de couche.
Le modèle contient des couches associées aux éléments de code.

La première fois que vous démarrez une instance expérimentale de Visual Studio pour tester votre extension de validation, ouvrez ou créez une solution avec ces caractéristiques.

Exécuter la commande Nettoyer la solution avant de valider l'architecture

Chaque fois que vous mettez à jour votre code de validation, utilisez la commande Nettoyer la solution dans le menu Générer de la solution expérimentale, avant de tester la commande Valider.Cela est nécessaire car les résultats de la validation sont mis en cache.Si vous n'avez pas mis à jour le diagramme de couche de test ou son code, les méthodes de validation ne seront pas exécutées.

Lancer le débogueur explicitement

La validation s'exécute dans un processus séparé.Par conséquent, les points d'arrêt dans votre méthode de validation ne seront pas déclenchés.Vous devez joindre explicitement le débogueur au processus lorsque la validation a démarré.

Pour joindre le débogueur au processus de validation, insérez un appel à System.Diagnostics.Debugger.Launch() au démarrage de votre méthode de validation.Lorsque la boîte de dialogue de débogage s'affiche, sélectionnez l'instance principale de Visual Studio.

Vous pouvez également insérer un appel à System.Windows.Forms.MessageBox.Show().Lorsque le message s'affiche, accédez à l'instance principale de Visual Studio et sur le bouton Attacher au processusde menu Déboguer . Sélectionnez le processus nommé Graphcmd.exe.

Démarrez toujours l'instance expérimentale en appuyant sur CTRL+F5 (Exécuter sans débogage).

Déploiement d'une extension de validation

Pour installer votre extension de validation sur un ordinateur sur lequel Visual Studio Ultimate ou Visual Studio Premium est installé, ouvrez le fichier VSIX sur l'ordinateur cible.Pour l'installer sur un ordinateur sur lequel Team Foundation Build est installé, vous devez extraire manuellement le contenu de VSIX dans un dossier Extensions.Pour plus d'informations, consultez Déploiement d'une extension de modélisation de couche.

Exemple de code

using System;
using System.ComponentModel.Composition;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.GraphModel;

namespace Validator3
{
    [Export(typeof(IValidateArchitectureExtension))]
    public partial class Validator3Extension : IValidateArchitectureExtension
    {
        /// <summary>
        /// Validate the architecture
        /// </summary>
        /// <param name="graph">The graph</param>
        public void ValidateArchitecture(Graph graph)
        {
            if (graph == null) throw new ArgumentNullException("graph");

            // Uncomment the line below to debug this extension during validation
            // System.Windows.Forms.MessageBox.Show("Attach 2 to GraphCmd.exe with process id " + System.Diagnostics.Process.GetCurrentProcess().Id);


            // Get all layers on the diagram
            foreach (GraphNode layer in graph.Nodes.GetByCategory("Dsl.Layer"))
            {
                System.Threading.Thread.Sleep(100);
                // Get the required regex property from the layer node
                string regexPattern = "^[a-zA-Z]+$"; //layer[customPropertyCategory] as string;
                if (!string.IsNullOrEmpty(regexPattern))
                {
                    Regex regEx = new Regex(regexPattern);

                    // Get all referenced types in this layer including those from nested layers so each
                    // type is validated against all containing layer constraints.
                    foreach (GraphNode containedType in layer.FindDescendants().Where(node => node.HasCategory("CodeSchema_Type")))
                    {
                        // Check the type name against the required regex                        
                        CodeGraphNodeIdBuilder builder = new CodeGraphNodeIdBuilder(containedType.Id, graph);
                        string typeName = builder.Type.Name;
                        if (!regEx.IsMatch(typeName))
                        {
                            // Log an error
                            string message = string.Format(CultureInfo.CurrentCulture, Resources.InvalidTypeNameMessage, typeName);
                            this.LogValidationError(graph, typeName + "TypeNameError", message, GraphErrorLevel.Error, layer);
                        }
                    }
                }

            }

        }
    }
}

Voir aussi

Concepts

Extension des diagrammes de couche

Partager via