Gewusst wie: Definieren von Validierungseinschränkungen für UML-Modelle

In Visual Studio Ultimate können Sie Validierungseinschränkungen definieren, die testen, ob das Modell eine von Ihnen angegebene Bedingung erfüllt. Sie können z. B. eine Einschränkung definieren, um sicherzustellen, dass ein Benutzer keine Schleife mit Vererbungsbeziehungen erstellt. Die Einschränkung wird aufgerufen, wenn der Benutzer versucht, das Modell zu öffnen oder zu speichern. Sie kann auch manuell aufgerufen werden. Wenn die Einschränkung fehlschlägt, wird dem Fehlerfenster eine von Ihnen definierte Fehlermeldung hinzugefügt. Sie können diese Einschränkungen in einer Visual Studio-Integrationserweiterung (VSIX) verpacken und an andere Visual Studio Ultimate-Benutzer verteilen.

Sie können auch Einschränkungen definieren, mit denen das Modell anhand externer Ressourcen (z. B. Datenbanken) überprüft wird.

Voraussetzungen

• Visual Studio 2010 SDK

• Visual Studio 2010-Visualisierungs- & Modellierungs-SDK. Weitere Informationen finden Sie in der Code Gallery unter Visual Studio-Visualisierungs- und Modellierungs-SDK.

Anwenden von Validierungseinschränkungen

Validierungseinschränkungen werden in drei Situationen angewendet: wenn Sie ein Modell speichern, wenn Sie ein Modell öffnen, und wenn Sie im Menü Architektur auf UML-Modell überprüfen klicken. In jedem Fall werden nur die Einschränkungen angewendet, die für die jeweiligen Situation definiert wurden. In der Regel werden Einschränkungen jedoch für mehrere Situationen definiert.

Validierungsfehler werden in den Fehlerfenstern von Visual Studio angezeigt. Sie können auf einen Fehler doppelklicken, um die betroffenen Modellelemente auszuwählen.

Weitere Informationen zum Anwenden der Validierung finden Sie unter Gewusst wie: Überprüfen eines UML-Modells.

Definieren einer Validierungserweiterung

Um eine Validierungserweiterung für einen UML-Designer zu erstellen, müssen Sie eine Klasse erstellen, welche die Validierungseinschränkungen definiert, und diese Klasse in eine Visual Studio-Integrationserweiterung (VSIX, Visual Studio Integration Extension) einbetten. Die VSIX fungiert als Container zum Installieren der Einschränkung. Es gibt zwei alternative Methoden zur Definition einer Validierungserweiterung:

• Erstellen einer Validierungserweiterung innerhalb der eigenen VSIX mithilfe einer Projektvorlage. Dies ist die schnellere Methode. Verwenden Sie diese Methode, wenn Sie die Validierungseinschränkungen nicht mit anderen Erweiterungstypen, z. B. Menübefehlen, benutzerdefinierten Toolboxelementen oder Gestenhandlern, kombinieren möchten. Sie können mehrere Einschränkungen in einer Klasse definieren.

• Erstellen separater Validierungsklassen und VSIX-Projekte. Verwenden Sie diese Methode, wenn Sie mehrere Erweiterungstypen in dieselbe VSIX kombinieren möchten. Wenn beispielsweise der Menübefehl erwartet, dass das Modell bestimmte Einschränkungen berücksichtigt, können Sie es in dieselbe VSIX wie eine Validierungsmethode einbetten.

So erstellen Sie eine Validierungserweiterung in der eigenen VSIX

1. Klicken Sie im Dialogfeld Neues Projekt unter Modellierungsprojekte auf Validierungserweiterung.

2. Öffnen Sie im neuen Projekt die .cs-Datei, und ändern Sie die Klasse, um die Validierungseinschränkung zu implementieren.

   Weitere Informationen finden Sie unter Implementieren der Validierungseinschränkung.

   Wichtig

   Stellen Sie sicher, dass die .cs-Dateien die folgende using-Anweisung enthalten:

   using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;

3. Sie können weitere Einschränkungen hinzufügen, indem Sie neue Methoden definieren. Um eine Methode als Validierungsmethode zu kennzeichnen, muss sie auf die gleiche Weise mit den Attributen markiert werden, wie die ursprüngliche Validierungsmethode.

4. Testen Sie die Einschränkungen, indem Sie F5 drücken. Weitere Informationen finden Sie unter Ausführen einer Validierung.

5. Installieren Sie den Menübefehl auf einem anderen Computer, indem Sie die vom Projekt erstellte Datei bin\*\*.vsix kopieren. Weitere Informationen finden Sie unter Installieren der Validierungseinschränkungen.

Wenn Sie andere .cs-Dateien hinzuzufügen, benötigen Sie normalerweise die folgenden using-Anweisungen:

using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.Modeling.Validation;
using Microsoft.VisualStudio.Uml.Classes;

So erstellen Sie eine separate Validierungseinschränkung in einem Klassenbibliotheksprojekt

1. Erstellen Sie ein Klassenbibliotheksprojekt. Sie können dieses entweder zu einer vorhandenen VSIX-Projektmappe hinzufügen, oder Sie können eine neue Projektmappe erstellen.

   1. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

   2. Klicken Sie unter Installierte Vorlagen auf Visual C# oder Visual Basic, und klicken Sie anschließend in der mittleren Spalte auf Klassenbibliothek.

   3. Legen Sie Projektmappe fest, um anzugeben, ob eine neue Projektmappe erstellt oder einer bereits geöffneten VSIX-Projektmappe eine Komponente hinzugefügt werden soll.

   4. Legen Sie Name und Speicherort für das Projekt fest, und klicken Sie auf OK.

2. Erstellen Sie ein VSIX-Projekt, sofern die Projektmappe noch kein VSIX-Projekt enthält.

   1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, zeigen Sie auf Hinzufügen, und klicken Sie anschließend auf Neues Projekt.

   2. Erweitern Sie unter Installierte Vorlagen den Knoten Visual C# oder Visual Basic, und klicken Sie anschließend auf Erweiterungen. Klicken Sie in der mittleren Spalte auf VSIX Project.

3. Legen Sie das VSIX-Projekt als Startprojekt der Projektmappe fest.

   • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das VSIX-Projekt, und klicken Sie anschließend auf Als Startprojekt festlegen.

4. Fügen Sie in source.extension.vsixmanifest unter Inhalt das Klassenbibliotheksprojekt als MEF-Komponente hinzu.

   1. Öffnen Sie source.extension.vsixmanifest.

   2. Klicken Sie auf Inhalt hinzufügen.

   3. Wählen Sie für Inhaltstyp auswählen die Option MEF-Komponente aus.

   4. Klicken Sie in Quelle auswählen auf Projekt, und wählen Sie den Namen des Klassenbibliotheksprojekts aus.

5. Klicken Sie auf Editionen auswählen, und wählen Sie die Visual Studio-Editionen aus, unter denen die Erweiterung ausgeführt werden soll.

6. Legen Sie den Namen und die Beschreibungsfelder des VSIX fest. Speichern Sie die Datei.

So definieren Sie die Validierungsklasse

1. Dieses Verfahren ist nicht erforderlich, wenn Sie eine Validierungsklasse mit einer eigenen VSIX aus der Validierungsprojektvorlage erstellt haben.

2. Fügen Sie im Projekt der Validierungsklasse Verweise auf die folgenden .NET-Assemblys hinzu:

   Microsoft.VisualStudio.Modeling.Sdk.10.0

   Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml

   Microsoft.VisualStudio.Uml.Interfaces

   System.ComponentModel.Composition

3. Fügen Sie dem Klassenbibliotheksprojekt eine Datei hinzu, die einen ähnlichen Code enthält, wie das folgende Beispiel.

   • Jede Validierungseinschränkung ist in einer Methode enthalten, die mit einem bestimmten Attribut markiert ist. Die Methode akzeptiert einen Parameter eines Modellelementtyps. Wenn die Validierung aufgerufen wird, wendet das Validierungsframework die einzelnen Validierungsmethoden auf jedes Modellelement an, das ihrem Parametertyp entspricht.

   • Sie können diese Methoden in beliebige Klassen und Namespaces einfügen. Ändern Sie sie nach Bedarf.

   using System.Collections.Generic;
   using System.ComponentModel.Composition;
   using System.Linq;
   using Microsoft.VisualStudio.Modeling.Validation;
   using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
   using Microsoft.VisualStudio.Uml.Classes;
   // You might also need the other Microsoft.VisualStudio.Uml namespaces.
   
   namespace Validation
   {
     public class MyValidationExtensions
     {
       // SAMPLE VALIDATION METHOD.
       // All validation methods have the following attributes.
       [Export(typeof(System.Action<ValidationContext, object>))]
       [ValidationMethod(
          ValidationCategories.Save
        | ValidationCategories.Open
        | ValidationCategories.Menu)]
       public void ValidateClassNames
         (ValidationContext context, 
          // This type determines what elements 
          // will be validated by this method:
          IClass elementToValidate)
       {
         // A validation method should not change the model.
   
         List<string> attributeNames = new List<string>();
         foreach (IProperty attribute in elementToValidate.OwnedAttributes)
         {
           string name = attribute.Name;
           if (!string.IsNullOrEmpty(name) && attributeNames.Contains(name))
           {
             context.LogError(
               string.Format("Duplicate attribute name '{0}' in class {1}", name, elementToValidate.Name),
               "001", elementToValidate);
           }
           attributeNames.Add(name);
         }
   
       }
       // Add more validation methods for different element types.
     }
   }
   

Ausführen einer Validierungseinschränkung

Führen Sie die Validierungsmethoden zu Testzwecken im Debugmodus aus.

So testen Sie die Validierungseinschränkung

1. Drücken Sie F5, oder klicken Sie im Menü Debuggen auf Debuggen starten.

   Eine experimentelle Instanz von Visual Studio wird gestartet.

   Problembehandlung: Wenn ein neuer Visual Studio nicht startet:

   • Wenn Sie mehr als ein Projekt haben, stellen Sie sicher, dass das VSIX-Projekt als Startprojekt der Projektmappe festgelegt wird.

   • Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Startprojekt oder das einzige Projekt, und klicken Sie dann auf Eigenschaften. Klicken Sie im Projekteigenschaften-Editor auf die Registerkarte Debuggen. Stellen Sie sicher, dass die Zeichenfolge im Feld Externes Programm starten der vollständige Pfadname von Visual Studio ist. Dieser lautet in der Regel:

     C:\Programme\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe

2. Öffnen oder erstellen Sie in der experimentellen Instanz von Visual Studio ein Modellierungsprojekt, und öffnen oder erstellen Sie ein Modellierungsdiagramm.

3. So richten Sie einen Test für die Beispieleinschränkung aus dem vorherigen Abschnitt ein

   1. Öffnen Sie ein Klassendiagramm.

   2. Erstellen Sie eine Klasse, und fügen Sie zwei Attribute hinzu, die denselben Namen aufweisen.

4. Klicken Sie mit der rechten Maustaste auf eine beliebige Stelle im Diagramm, und klicken Sie anschließend auf Überprüfen.

5. Alle Fehler im Modell werden im Fehlerfenster angezeigt.

6. Doppelklicken Sie auf den Fehlerbericht. Wenn die im Bericht erwähnten Elemente auf dem Bildschirm sichtbar sind, werden sie hervorgehoben.

   Problembehandlung: Wenn der Befehl Überprüfen nicht im Menü angezeigt wird, stellen Sie Folgendes sicher:

   • Das Validierungsprojekt ist im VSIX-Projekt in source.extensions.manifest in der Liste Inhalt als MEF-Komponente aufgeführt.

   • An die Validierungsmethoden sind das richtige Export-Attribut und das richtige ValidationMethod-Attribut angefügt.

   • ValidationCategories.Menu ist im Argument für das ValidationMethod-Attribut enthalten, und es wird mit dem logischen Operator OR (|) mit anderen Werten verfasst.

   • Die Parameter aller Import-Attribute und Export-Attribute sind gültig.

Auswerten der Einschränkung

Die Validierungsmethode sollte bestimmen, ob die anzuwendende Validierungseinschränkung den Wert true oder false hat. Bei "true" soll keine Aktion erfolgen. Bei "false" sollte ein Fehler gemeldet werden, indem die vom ValidationContext-Parameter bereitgestellten Methoden verwendet werden.

Wenn Sie z. B. sicherstellen möchten, dass der Name jedes Typs (Klasse, Schnittstelle oder Enumerator) mindestens drei Zeichen lang ist, können Sie die folgende Methode verwenden:

public void ValidateTypeName(ValidationContext context, IType type)
{
  if (!string.IsNullOrEmpty(type.Name) && type.Name.Length < 3)
  {
    context.LogError(
      string.Format("Type name {0} is too short", type.Name),
               "001", type);
   }
 }

Weitere Informationen zu den Methoden und Typen zum Navigieren im Modell und Lesen des Modells finden Sie unter Programmieren mit der UML-API.

Informationen zu Validierungseinschränkungsmethoden

Jede Validierungseinschränkung wird von einer Methode der folgenden Form definiert:

[Export(typeof(System.Action<ValidationContext, object>))]
 [ValidationMethod(ValidationCategories.Save 
  | ValidationCategories.Menu 
  | ValidationCategories.Open)]
public void ValidateSomething
  (ValidationContext context, IClassifier elementToValidate)
{...}

Die Attribute und Parameter jeder Validierungsmethode lauten wie folgt:

Sie können beliebig viele Validierungsmethoden mit unterschiedlichen Typen im zweiten Parameter definieren. Wenn die Validierung aufgerufen wird, wird jede Validierungsmethode für jedes dem Parametertyp entsprechende Modellelement aufgerufen.

Melden von Validierungsfehlern

Um einen Fehlerbericht zu erstellen, verwenden Sie die von ValidationContext bereitgestellten Methoden:

context.LogError("error string", errorCode, elementsWithError);

• "error string" wird in der Visual Studio-Fehlerliste angezeigt

• errorCode ist eine Zeichenfolge, bei der es sich um einen eindeutigen Bezeichner des Fehlers handelt

• elementsWithError identifiziert Elemente im Modell. Wenn Benutzer auf den Fehlerbericht doppelklicken, wird die Form ausgewählt, die dieses Element darstellt.

LogError(), LogWarning() und LogMessage() platzieren Meldungen in den verschiedenen Abschnitten der Fehlerliste.

Anwenden von Validierungsmethoden

Die Validierung wird auf jedes Element im Modell angewendet, einschließlich Beziehungen und Teile größerer Elemente, z. B. Attribute einer Klasse und Parameter einer Operation.

Jede Validierungsmethode wird auf jedes Element angewendet, das dem Typ im zweiten Parameter entspricht. Wenn Sie z. B. eine Validierungsmethode mit einem zweiten Parameter IUseCase und eine weitere Methode mit dem übergeordneten Typ IElement definieren, werden folglich beide Methoden auf jeden Anwendungsfall im Modell angewendet.

Eine Zusammenfassung der Typhierarchie finden Sie unter Modellelementtypen.

Sie können auch über Beziehungen auf Elemente zugreifen. Wenn Sie z. B. eine Validierungsmethode für IClass definieren möchten, könnten Sie die im Besitz befindlichen Eigenschaften in einer Schleife durchlaufen:

public void ValidateTypeName(ValidationContext context, IClass c)
{
   foreach (IProperty property in c.OwnedAttributes)
   {
       if (property.Name.Length < 3)
       {
            context.LogError(
                 string.Format(
                        "Property name {0} is too short", 
                        property.Name), 
                 "001", property);
        }
   }
}

Erstellen einer Validierungsmethode für das Modell

Wenn Sie sicherstellen möchten, dass eine Validierungsmethode während jeder Validierungsausführung genau einmal aufgerufen wird, können Sie das IModel überprüfen:

using Microsoft.VisualStudio.Uml.AuxiliaryConstructs; ...
[Export(typeof(System.Action<ValidationContext, object>))]
[ValidationMethod(ValidationCategories.Menu)]
public void ValidateModel(ValidationContext context, IModel model)
{  foreach (IElement element in model.OwnedElements)
   { ...

Überprüfen von Formen und Diagrammen

Validierungsmethoden werden nicht für Anzeigeelemente wie Diagramme und Formen aufgerufen, da der primäre Zweck von Validierungsmethoden die Überprüfung des Modells ist. Sie können jedoch mithilfe des Diagrammkontexts auf das aktuelle Diagramm zugreifen.

Deklarieren Sie in der Validierungsklasse DiagramContext als importierte Eigenschaft:

using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation; 
...
[Import]
public IDiagramContext DiagramContext { get; set; }

In einer Validierungsmethode können Sie mit DiagramContext auf das Diagramm zugreifen, das zurzeit den Fokus hat (sofern ein Diagramm den Fokus hat):

[Export(typeof(System.Action<ValidationContext, object>))]
[ValidationMethod(ValidationCategories.Menu)]
public void ValidateModel(ValidationContext context, IModel model)
{
  IDiagram focusDiagram = DiagramContext.CurrentDiagram;
  if (focusDiagram != null)
  {
    foreach (IShape<IUseCase> useCaseShape in
              focusDiagram.GetChildShapes<IUseCase>())
    { ...

Um einen Fehler zu protokollieren, müssen Sie das von der Form dargestellte Modellelement abrufen, da es nicht möglich ist, eine Form an LogError zu übergeben:

       IUseCase useCase = useCaseShape.Element;
       context.LogError(... , usecase);

Koordinieren mehrerer Validierungen

Wenn die Validierung aufgerufen wird (z. B. vom Benutzer über ein Diagrammmenü), wird jede Validierungsmethode auf jedes Modellelement angewendet. Dies bedeutet, dass dieselbe Methode für einen einzelnen Aufruf des Validierungsframeworks viele Male auf verschiedene Elemente angewendet werden kann.

Dies stellt ein Problem für Validierungen dar, die sich mit den Beziehungen zwischen Elementen beschäftigen. Sie können z. B. eine Validierung schreiben, die von einem Anwendungsfall ausgeht und die include-Beziehungen durchläuft, um sicherzustellen, dass keine Schleifen vorhanden sind. Wenn die Methode jedoch auf jeden Anwendungsfall in einem Modell angewendet wird, das über viele include-Links verfügt, ist es wahrscheinlich, dass immer die gleichen Bereiche des Modells verarbeitet werden.

Um diese Situation zu vermeiden, gibt es einen Kontextcache, in dem Informationen während einer Validierungsausführung beibehalten werden. Sie können ihn verwenden, um Informationen zwischen verschiedenen Ausführungen der Validierungsmethoden zu übergeben. Beispielsweise können Sie eine Liste der Elemente speichern, die während einer Validierungsausführung bereits verarbeitet wurden. Der Cache wird zu Beginn jeder Validierungsausführung erstellt und kann nicht verwendet werden, um Informationen zwischen verschiedenen Validierungsausführungen zu übergeben.

Installieren und Deinstallieren einer Erweiterung

Sie können eine Visual Studio-Erweiterung sowohl auf Ihrem eigenen Computer als auch auf anderen Computern installieren.

So installieren Sie eine Erweiterung

1. Suchen Sie auf dem Computer nach der .vsix-Datei, die vom VSIX-Projekt erstellt wurde.

   1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das VSIX-Projekt, und klicken Sie dann auf Ordner in Windows Explorer öffnen.

   2. Suchen Sie nach der Datei bin\*\IhrProjekt.vsix.

2. Kopieren Sie die .vsix-Datei auf den Zielcomputer, auf dem Sie die Erweiterung installieren möchten. Dies kann Ihr eigener Computer oder ein anderer Computer sein.

   • Der Zielcomputer muss über eine der Editionen von Visual Studio verfügen, die Sie in source.extension.vsixmanifest angegeben haben.

3. Doppelklicken Sie auf dem Zielcomputer auf die .vsix-Datei.

   Installer für Visual Studio-Erweiterungen wird geöffnet, und die Erweiterung wird installiert.

4. Starten Sie Visual Studio, bzw. starten Sie die Anwendung neu.

So deinstallieren Sie eine Erweiterung

1. Klicken Sie im Menü Extras auf Erweiterungs-Manager.

2. Erweitern Sie Installierte Erweiterungen.

3. Wählen Sie die Erweiterung aus, und klicken Sie dann auf Deinstallieren.

In seltenen Fällen kann es vorkommen, dass eine fehlerhafte Erweiterung nicht geladen und ein Bericht im Fehlerfenster erstellt wird, aber im Erweiterungs-Manager keine Informationen angezeigt werden. In diesem Fall können Sie die Erweiterung löschen, indem Sie die Datei von folgendem für % LocalAppData% üblichen Speicherort entfernen: DriveName: \Users\UserName\AppData\Local:

%LocalAppData%\Microsoft\VisualStudio\10.0\Extensions

Beispiel

In diesem Beispiel wird nach Schleifen in der Abhängigkeitsbeziehung zwischen Elementen gesucht.

Die Validierung erfolgt für Speichervorgänge und für den Menübefehl zum Überprüfen.

/// <summary>
/// Verify that there are no loops in the dependency relationsips.
/// In our project, no element should be a dependent of itself.
/// </summary>
/// <param name="context">Validation context for logs.</param>
/// <param name="element">Element to start validation from.</param>
[Export(typeof(System.Action<ValidationContext, object>))]
[ValidationMethod(ValidationCategories.Menu 
     | ValidationCategories.Save | ValidationCategories.Open)]
public void NoDependencyLoops(ValidationContext context, INamedElement element)
{
    // The validation framework will call this method
    // for every element in the model. But when we follow
    // the dependencies from one element, we will validate others.
    // So we keep a list of the elements that we don't need to validate again. 
    // The list is kept in the context cache so that it is passed
    // from one execution of this method to another.
    List<INamedElement> alreadySeen = null;
    if (!context.TryGetCacheValue("No dependency loops", out alreadySeen))
    {
       alreadySeen = new List<INamedElement>();
       context.SetCacheValue("No dependency loops", alreadySeen);
    }

    NoDependencyLoops(context, element, 
                new INamedElement[0], alreadySeen);    
}

/// <summary>
/// Log an error if there is any loop in the dependency relationship.
/// </summary>
/// <param name="context">Validation context for logs.</param>
/// <param name="element">The element to be validated.</param>
/// <param name="dependants">Elements we've followed in this recursion.</param>
/// <param name="alreadySeen">Elements that have already been validated.</param>
/// <returns>true if no error was detected</returns>
private bool NoDependencyLoops(ValidationContext context, 
    INamedElement element, INamedElement[] dependants, 
    List<INamedElement> alreadySeen)
{
    if (dependants.Contains(element))
    {
        context.LogError(string.Format("{0} should not depend on itself", element.Name), 
        "Fabrikam.UML.NoGenLoops", // unique code for this error
        dependants.SkipWhile(e => e != element).ToArray()); 
            // highlight elements that are in the loop
        return false;
    }
    INamedElement[] dependantsPlusElement = 
        new INamedElement[dependants.Length + 1];
    dependants.CopyTo(dependantsPlusElement, 0);
    dependantsPlusElement[dependantsPlusElement.Length - 1] = element;

    if (alreadySeen.Contains(element))
    {
        // We have already validated this when we started 
        // from another element during this validation run.
        return true;
    }
    alreadySeen.Add(element);

    foreach (INamedElement supplier in element.GetDependencySuppliers())
    {
        if (!NoDependencyLoops(context, supplier,
             dependantsPlusElement, alreadySeen))
        return false;
    }
    return true;
}

Siehe auch

Weitere Ressourcen

Gewusst wie: Definieren und Installieren einer Modellierungserweiterung

Programmieren mit der UML-API