Freigeben über

Hinzufügen einer benutzerdefinierten Architekturüberprüfung zu Ebenendiagrammen

  • Artikel

In Visual Studio Ultimate und Visual Studio Premium können Benutzer den Quellcode in einem Visual Studio-Projekt anhand eines Ebenenmodells überprüfen. So kann festgestellt werden, ob der Quellcode den Abhängigkeiten in einem Ebenendiagramm entspricht. Es gibt zwar einen Standardvalidierungsalgorithmus, Sie können aber auch eigene Überprüfungserweiterungen für Visual Studio Ultimate und Visual Studio Premium definieren.

Wenn der Benutzer den Befehl Architektur überprüfen für ein Ebenendiagramm auswählt, wird die Standardvalidierungsmethode aufgerufen, anschließend folgen alle installierten Validierungserweiterungen.

Hinweis

Die Validierung in einem Ebenendiagramm ist nicht mit einer Validierung in UML-Diagrammen vergleichbar.In einem Ebenendiagramm dient sie hauptsächlich dazu, das Diagramm mit dem Programmcode in anderen Teilen der Projektmappe zu vergleichen.

Sie können die Ebenenvalidierungserweiterung in eine Visual Studio-Integrationserweiterung (VSIX) verpacken, die Sie an andere Visual Studio Ultimate-Benutzer verteilen. Sie können entweder das Validierungssteuerelement allein in eine VSIX einfügen, oder Sie können es in der gleichen VSIX mit anderen Erweiterungen kombinieren. Schreiben Sie den Code für das Validierungssteuerelement in einem eigenen Visual Studio-Projekt und nicht im gleichen Projekt wie andere Erweiterungen.

Warnung

Nachdem Sie ein Überprüfungsprojekt erstellt haben, kopieren Sie den Beispielcode am Ende dieses Themas und bearbeiten diesen dann Ihren Anforderungen entsprechend.

Anforderungen

  • Visual Studio Ultimate

  • SDK von Visual Studio

  • Visual Studio Visualization and Modeling SDK

Definieren eines Ebenenvalidierungssteuerelements in einer neuen VSIX

Projektvorlagen stellen die schnellste Methode dar, eine Validierungssteuerelement zu erstellen. Dabei werden der Code und die VSIX im selben Projekt platziert.

So definieren Sie mithilfe einer Projektvorlage eine Erweiterung

  1. Erstellen Sie in einer neuen Projektmappe ein Projekt. Verwenden Sie dazu den Befehl Neues Projekt im Menü Datei.

  2. Klicken Sie im Dialogfeld Neues Projekt unter Modellierungsprojekte auf Layer Designer Validation Extension (Ebenen-Designer - Validierungserweiterung).

    Mit dieser Vorlage wird ein Projekt mit einem kleinen Beispiel erstellt.

    Warnung

    Führen Sie Folgendes durch, damit die Vorlage ordnungsgemäß funktioniert:

    • Bearbeiten Sie Aufrufe zu LogValidationError, um die optionalen Argumente errorSourceNodes und errorTargetNodes zu entfernen.

    • Wenn Sie benutzerdefinierte Eigenschaften verwenden, wenden Sie das unter Hinzufügen von benutzerdefinierten Eigenschaften zu einem Ebenendiagramm erwähnte Update an.Öffnen Sie außerdem den Architektur-Explorer, bevor Sie eine Modellprojektmappe öffnen.

  3. Bearbeiten Sie den Code, um die Validierung zu definieren. Weitere Informationen finden Sie unter Programmieren einer Validierung.

  4. Weitere Informationen zum Testen der Erweiterung finden Sie unter Debuggen der Ebenenvalidierung.

    Hinweis

    Die Methode wird nur unter bestimmten Umständen aufgerufen, und Haltepunkte funktionieren nicht automatisch.Weitere Informationen finden Sie unter Debuggen der Ebenenvalidierung.

  5. Um die Erweiterung in der Hauptinstanz von Visual Studio oder auf einem anderen Computer zu installieren, suchen Sie die Datei .vsix im Ordner bin\*. Kopieren Sie die Datei auf den Computer, auf dem Sie sie installieren möchten, und doppelklicken Sie dann darauf. Verwenden Sie Erweiterungs-Manager im Menü Extras zum Deinstallieren der Datei.

Hinzufügen eines Ebenenvalidierungssteuerelements zu einer separaten VSIX

Wenn Sie eine VSIX erstellen möchten, die Ebenenvalidierungssteuerelemente, Befehle und andere Erweiterungen enthält, empfiehlt es sich, ein Projekt zum Definieren der VSIX und getrennte Projekte für die Handler zu erstellen. Informationen zu anderen Modellerweiterungstypen finden Sie unter Erweitern von UML-Modellen und Diagrammen.

So fügen Sie einer separaten VSIX eine Ebenenvalidierung hinzu

  1. Erstellen Sie in einer neuen oder vorhandenen Visual Studio Ultimate-Projektmappe ein Klassenbibliotheksprojekt. Klicken Sie im Dialogfeld Neues Projekt auf Visual C#, und klicken Sie dann auf Klassenbibliothek. Dieses Projekt enthält die Ebenenvalidierungsklasse.

  2. Identifizieren oder erstellen Sie ein VSIX-Projekt in der Projektmappe. Ein VSIX-Projekt enthält eine Datei mit dem Namen source.extension.vsixmanifest. Wenn Sie ein VSIX-Projekt hinzufügen müssen, führen Sie die folgenden Schritte aus:

    1. Wählen Sie im Dialogfeld Neues Projekt die Optionen Visual C#Erweiterungen, Erweiterungen und VSIX-Projekt aus.

    2. Wählen Sie im Projektmappen-Explorer im Kontextmenü des VSIX-Projekts die Option Als Startprojekt festlegen aus.

  3. Fügen Sie in source.extension.vsixmanifest unter Objekte das Ebenenvalidierungsprojekt als MEF-Komponente hinzu:

    1. Wählen Sie Neu aus.

    2. Legen Sie im Dialogfeld Neues Objekt hinzufügen Folgendes fest:

      Typ = Microsoft.VisualStudio.MefComponent

      Quelle = Ein Projekt in der aktuellen Projektmappe

      Projekt = your validator project

  4. Außerdem müssen Sie das Projekt als Ebenenvalidierung hinzufügen:

    1. Wählen Sie Neu aus.

    2. Legen Sie im Dialogfeld Neues Objekt hinzufügen Folgendes fest:

      Typ = Microsoft.VisualStudio.ArchitectureTools.Layer.Validator. Dies ist keine der Optionen in der Dropdownliste. Sie müssen den Typ über die Tastatur eingeben.

      Quelle = Ein Projekt in der aktuellen Projektmappe

      Projekt = your validator project

  5. Kehren Sie zum Ebenenvalidierungsprojekt zurück, und fügen Sie die folgenden Projektverweise hinzu:

    Verweis

    Optionen

    Microsoft.VisualStudio.GraphModel.dll

    Lesen des Architekturdiagramms

    Microsoft.VisualStudio.ArchitectureTools.Extensibility.CodeSchema.dll

    Lesen des Ebenen zugeordneten Code-DOMs

    Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll

    Lesen des Ebenenmodells

    Microsoft.VisualStudio.ArchitectureTools.Extensibility

    Lesen und Aktualisieren von Formen und Diagrammen.

    System.ComponentModel.Composition

    Definieren der Validierungskomponente mithilfe von Managed Extensibility Framework (MEF)

    Microsoft.VisualStudio.Modeling.Sdk.12.0

    Definieren von Modellierungserweiterungen

  6. Kopieren Sie den Beispielcode am Ende dieses Themas in die Klassendatei im Bestätigungsbibliotheksprojekt, damit sie den Code für die Überprüfung enthält. Weitere Informationen finden Sie unter Programmieren einer Validierung.

  7. Weitere Informationen zum Testen der Erweiterung finden Sie unter Debuggen der Ebenenvalidierung.

    Hinweis

    Die Methode wird nur unter bestimmten Umständen aufgerufen, und Haltepunkte funktionieren nicht automatisch.Weitere Informationen finden Sie unter Debuggen der Ebenenvalidierung.

  8. Um die Erweiterung in der Hauptinstanz von Visual Studio oder auf einem anderen Computer zu installieren, suchen Sie die Datei .vsix im Verzeichnis bin des VSIX-Projekts. Kopieren Sie die Datei auf den Computer, auf dem Sie die VSIX installieren möchten. Doppelklicken Sie in Windows-Explorer auf die VSIX-Datei. (Datei-Explorer in Windows 8.)

    Verwenden Sie Erweiterungs-Manager im Menü Extras zum Deinstallieren der Datei.

Programmieren einer Validierung

Zum Definieren einer Ebenenvalidierungserweiterung definieren Sie eine Klasse, die über die folgenden Eigenschaften verfügt:

  • Die allgemeine Form der Deklaration lautet wie folgt:

    
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;
      ...
  } }

  • Wenn Sie einen Fehler entdecken, können Sie ihn mit LogValidationError() melden.

    Warnung

    Verwenden Sie nicht die optionalen Parameter von LogValidationError.

Wenn der Benutzer den Menübefehl Architektur überprüfen aufruft, werden die Ebenen und ihre Artefakte vom Ebenenlaufzeitsystem analysiert, und es wird ein Diagramm erstellt. Das Diagramm besteht aus vier Teilen:

  • Den Ebenenmodellen der Visual Studio-Projektmappe, die als Knoten und Links im Diagramm dargestellt werden.

  • Dem Code, Projektelementen und anderen Artefakte, die in der Projektmappe definiert und als Knoten dargestellt werden, sowie den Links, die die vom Analyseprozess ermittelten Abhängigkeiten vertreten.

  • Links von den Ebenenknoten zu den Codeartefaktknoten.

  • Knoten, die die vom Validierungssteuerelement ermittelten Fehler darstellen.

Wenn das Diagramm erstellt wurde, wird die Standardvalidierungsmethode aufgerufen. Nachdem diese abgeschlossen ist, werden alle installierten Erweiterungsvalidierungsmethoden ohne spezifische Reihenfolge aufgerufen. Das Diagramm wird an jede ValidateArchitecture-Methode übergeben, die das Diagramm überprüfen und gefundene Fehler melden kann.

Hinweis

Dies ist nicht mit dem Validierungsprozess gleichzusetzen, der auf UML-Diagramme angewendet wird und auch nicht mit dem Validierungsprozess, der bei domänenspezifischen Sprachen verwendet werden kann.

Validierungsmethoden sollten das zu überprüfende Ebenenmodell oder den Code nicht ändern.

Das Diagrammmodell wird in Microsoft.VisualStudio.GraphModel definiert. Seine Prinzipalklassen sind GraphNode und GraphLink.

Jeder Knoten und jeder Link verfügt über mindestens eine Kategorie, die den Typ des Elements oder der Beziehung angibt, die von ihr dargestellt wird. Die Knoten eines typischen Diagramms verfügen über die folgenden Kategorien:

  • Dsl.LayerModel

  • Dsl.Layer

  • Dsl.Reference

  • CodeSchema_Type

  • CodeSchema_Namespace

  • CodeSchema_Type

  • CodeSchema_Method

  • CodeSchema_Field

  • CodeSchema_Property

Links von Ebenen zu Elementen im Code haben die Kategorie "Represents".

Debuggen der Validierung

Drücken Sie STRG+F5, um die Ebenenvalidierungserweiterung zu debuggen. Eine experimentelle Instanz von Visual Studio wird geöffnet. Öffnen oder erstellen Sie ein Ebenenmodell in dieser Instanz. Dieses Modell muss Code zugeordnet sein und muss mindestens eine Abhängigkeit besitzen.

Test mit einer Projektmappe, die Abhängigkeiten enthält

Die Validierung wird erst ausgeführt, wenn die folgenden Eigenschaften vorhanden sind:

  • Es gibt mindestens einen Abhängigkeitslink im Ebenendiagramm.

  • Es gibt Ebenen im Modell, die Codeelementen zugeordnet sind.

Öffnen oder erstellen Sie eine Projektmappe mit diesen Eigenschaften, wenn Sie eine experimentelle Instanz von Visual Studio zum ersten Mal zum Testen der Validierungserweiterung starten.

Ausführen einer Projektmappenbereinigung vor dem Überprüfen der Architektur

Verwenden Sie bei jeder Aktualisierung des Validierungscodes im Menü Erstellen der experimentellen Instanz den Befehl Projektmappe bereinigen, bevor Sie den Befehl "Überprüfen" testen. Dies ist notwendig, da die Ergebnisse der Validierung zwischengespeichert werden. Wenn das Testebenendiagramm oder sein Code nicht aktualisiert wurden, werden die Validierungsmethoden nicht ausgeführt.

Explizites Starten des Debuggers

Die Validierung wird in einem separaten Prozess ausgeführt. Daher werden die Haltepunkte in der Überprüfungsmethode nicht ausgelöst. Sie müssen den Debugger explizit dem Prozess anfügen, wenn die Validierung gestartet wurde.

Fügen Sie am Anfang der Validierungsmethode einen Aufruf von System.Diagnostics.Debugger.Launch() ein, um den Debugger dem Validierungsprozess anzufügen. Wenn das Debugdialogfeld angezeigt wird, wählen Sie die Hauptinstanz von Visual Studio aus.

Alternativ können Sie einen Aufruf von System.Windows.Forms.MessageBox.Show() einfügen. Wenn das Meldungsfeld angezeigt wird, wechseln Sie zur Hauptinstanz von Visual Studio, und klicken Sie im Menü Debuggen auf An den Prozess anhängen. Wählen Sie den Prozess mit dem Namen Graphcmd.exe aus.

Starten Sie die experimentelle Instanz immer mit STRG+F5 (Starten ohne Debugging).

Bereitstellen einer Validierungserweiterung

Öffnen Sie die VSIX-Datei auf dem Zielcomputer, um die Validierungserweiterung auf einem Computer zu installieren, auf dem Visual Studio Ultimate oder Visual Studio Premium installiert ist. Um die Installation auf einem Computer mit Team Foundation Build auszuführen, müssen Sie den VSIX-Inhalt manuell in einen Ordner "Extensions" extrahieren. Weitere Informationen finden Sie unter Bereitstellen einer Ebenenmodellierungserweiterung.

Beispielcode

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);
                        }
                    }
                }

            }

        }
    }
}

Siehe auch

Konzepte

Erweitern von Ebenendiagrammen