Gewusst wie: Navigieren in Beziehungen mit der UML-API

In Visual Studio Ultimate besteht ein Modell aus Elementen, die über unterschiedliche Beziehungen miteinander verknüpft sind.In diesem Thema wird beschrieben, wie Sie im Programmcode im Modell navigieren.

Durchlaufen von Beziehungen

Beliebige Beziehung

Verwenden Sie GetRelatedElements<T>(), um nach allen Elementen zu suchen, die mit einem angegebenen Element verbunden sind.Legen Sie entweder T auf IRelationship fest, um Beziehungen aller Arten zu durchlaufen, oder verwenden Sie einen spezifischeren Typ wie IAssociation, um nur diesen Typ zu durchlaufen.

IElement anElement;
// Select all elements related to anElement.
Context.CurrentDiagram.SelectShapes (
   anElement.GetRelatedElements<IRelationship>()
    .SelectMany(e=>e.Shapes()).ToArray());

Verwenden Sie GetRelatedLinks<T>(), um nach allen Beziehungen zu suchen, die mit einem Element verbunden sind.

// Process all relationships connected to an element.
foreach (IRelationship relationship in 
   anElement.GetRelatedLinks<IRelationship>())
{
  Debug.Assert(relationship.SourceElement == anElement
      || relationship.TargetElement == anElement);
}

Zuordnung

Eine Zuordnung ist eine Beziehung zwischen zwei Eigenschaften, die jeweils zu einem Klassifizierer gehören.

IClassifier classifier; // class, interface, component, actor, ...
// Get all the associations sourced from this classifier
foreach (IProperty p in classifier.GetOutgoingAssociationEnds())
{
  // p represents the end further end of an association.
  IType oppositeElement = p.Type; 
    // The type to which this association connects classifier
  
  IProperty oppositeProperty = p.Opposite;
    // The nearer end of the association.
  Debug.Assert(oppositeProperty.Type == classifier);
  IAssociation association = p.Association;
  Debug.Assert(association.MemberEnds.Contains(p)
     && association.MemberEnds.Contains(oppositeProperty));
}

 Generalisierung und Realisierung

Greifen Sie auf die entgegengesetzten Enden der Generalisierung zu:

foreach (IClassifier supertype in classifier.Generals) {…}
foreach (IClassifier subtype in classifier.GetSpecifics()) {…}
Access the relationship itself:
foreach (IGeneralization gen in classifier.Generalizations) 
{ Debug.Assert(classifier == gen.Specific); }

/// InterfaceRealization:
IEnumerable<IInterface> GetRealizedInterfaces
    (this IBehavioredClassifier classifier);
IEnumerable<IBehavioredClassifier> GetRealizingClassifiers
    (this IInterface interface);
 

Abhängigkeit

/// Returns the elements depending on this element
IEnumerable<INamedElement> GetDependencyClients(this INamedElement element); 
/// Returns the elements this element depends on
IEnumerable<INamedElement> INamedElement GetDependencySuppliers(this INamedElement element);
 

Aktivitätsrand

/// Returns the nodes targeted by edges outgoing from this one
IEnumerable<IActivityNode> GetActivityEdgeTargets(this IActivityNode node);
/// Returns the nodes sourcing edges incoming to this one
IEnumerable<IActivityNode> GetActivityEdgeSources(this IActivityNode node);
 

Konnektor (Assembly und Delegierung)

/// Returns the elements connected via assembly 
/// or delegation to this one
IEnumerable<IConnectableElement> GetConnectedElements(this IConnectableElement element);
 

Meldungen und Lebenslinien

IEnumerable<IMessage> GetAllOutgoingMessages(this ILifeline  lifeline); 
// both from lifeline and execution occurrences
IEnumerable<IMessage> GetAllIncomingMessages(this ILifeline  lifeline);
ILifeline GetSourceLifeline(this IMessage message); 
    // may return null for found messages
ILifeline GetTargetLifeline(this IMessage message);  
    // may return null for lost messages
 

Paketimport

IEnumerable<IPackage>GetImportedPackages(this INamespace namespace);
IEnumerable<INamespace> GetImportingNamespaces(this IPackage package);
 

Anwendungsfall (Extend/Include)

IEnumerable<IUseCase>GetExtendedCases(this IUseCase usecase);
IEnumerable<IUseCase>GetExtendingCases(this IUseCase usecase);
IEnumerable<IUseCase>GetIncludedCases(this IUseCase usecase);
IEnumerable<IUseCase>GetIncludingCases(this IUseCase usecase);

 Auflisten von Beziehungen

Alle Eigenschaften des UML-Modells, die mehrere Werte zurückgeben, entsprechen der IEnumerable<>-Schnittstelle.Dies bedeutet, dass Sie LINQ-Abfrageausdrücke und die im System.Linq-Namespace definierten Erweiterungsmethoden verwenden können.

Beispiele:

from shape in     Context.CurrentDiagram.GetSelectedShapes<IClassifier>()
where shape.Color == System.Drawing.Color.Red
select shape.Element

Siehe auch

Konzepte

Erweitern von UML-Modellen und Diagrammen

Gewusst wie: Navigieren im UML-Modell