Comment : naviguer parmi les relations avec l'API UML
Dans Visual Studio Ultimate, un modèle se compose d'éléments liés ensemble par différents genres de relations. Cette rubrique explique comment naviguer dans le modèle, dans le code du programme.
Parcours de relations
N'importe quelle relation
Utilisez GetRelatedElements<T>() pour rechercher tous les éléments connectés à un élément spécifié. Affectez la valeur IRelationship à T pour parcourir des relations de tous genres ou utilisez un type plus spécifique comme IAssociation pour parcourir uniquement ce type.
IElement anElement;
// Select all elements related to anElement.
Context.CurrentDiagram.SelectShapes (
anElement.GetRelatedElements<IRelationship>()
.SelectMany(e=>e.Shapes()).ToArray());
Utilisez GetRelatedLinks<T>() pour rechercher toutes les relations connectées à un élément.
// Process all relationships connected to an element.
foreach (IRelationship relationship in
anElement.GetRelatedLinks<IRelationship>())
{
Debug.Assert(relationship.SourceElement == anElement
|| relationship.TargetElement == anElement);
}
Association
Une association est une relation entre deux propriétés, dont chacune appartient à un classifieur.
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));
}
Généralisation et réalisation
Accédez aux extrémités opposées de généralisation :
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);
Dépendance
/// 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);
Bord d'activité
/// 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);
Connecteur (assembly et délégation)
/// Returns the elements connected via assembly
/// or delegation to this one
IEnumerable<IConnectableElement> GetConnectedElements(this IConnectableElement element);
Messages et lignes de vie
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
Importation de packages
IEnumerable<IPackage>GetImportedPackages(this INamespace namespace);
IEnumerable<INamespace> GetImportingNamespaces(this IPackage package);
Extension et inclusion de cas d'usage
IEnumerable<IUseCase>GetExtendedCases(this IUseCase usecase);
IEnumerable<IUseCase>GetExtendingCases(this IUseCase usecase);
IEnumerable<IUseCase>GetIncludedCases(this IUseCase usecase);
IEnumerable<IUseCase>GetIncludingCases(this IUseCase usecase);
Énumération des relations
Toutes les propriétés du modèle UML qui retournent plusieurs valeurs sont conformes à l'interface IEnumerable<>. Cela signifie que vous pouvez utiliser les expressions de requête LINQ et les méthodes d'extension définies dans l'espace de noms System.Linq.
Par exemple :
from shape in Context.CurrentDiagram.GetSelectedShapes<IClassifier>()
where shape.Color == System.Drawing.Color.Red
select shape.Element