Jak: Edycja diagramy sekwencji za pomocą interfejsu API UML

Artykuł
02/27/2013

Interakcji jest sekwencja komunikaty między zestaw linie życia.Interakcji jest wyświetlana na diagramie sekwencji.

Pełne informacje na temat interfejsu API, zobacz Microsoft.VisualStudio.Uml.Interactions.

Aby uzyskać bardziej ogólne wprowadzenie do pisania, polecenia i programy obsługi gestu dla diagramów UML, zobacz Jak: Definiowanie polecenia Menu na diagramie modelowania.

Kod podstawowe

Przywóz do obszaru nazw

Musi zawierać następujące using instrukcji:

using Microsoft.VisualStudio.Uml.Classes;
   // for basic UML types such as IPackage
using Microsoft.VisualStudio.Uml.Interactions;
   // for interaction types
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
   // to create elements and use additional functions

Jeśli tworzysz poleceń menu i gest obsługi, będzie również konieczne:

using System.ComponentModel.Composition; 
   // for Import and Export
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
   // for ICommandExtension
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
   // for diagrams and context

Aby uzyskać więcej informacji, zobacz Jak: Definiowanie polecenia Menu na diagramie modelowania.

Uzyskiwanie kontekście

Jeśli edytujesz interakcji jako część obsługi polecenia lub gestu w diagramie sekwencji można uzyskać odniesienie do kontekstu.Na przykład:

    [SequenceDesignerExtension]
    [Export(typeof(ICommandExtension))]  
    public class MySequenceDiagramCommand : ICommandExtension
    {
        [Import]
        public IDiagramContext Context { get; set; }
        public void QueryStatus (IMenuCommand command)
        {
          ISequenceDiagram sequenceDiagram = 
              Context.CurrentDiagram as ISequenceDiagram;
             ...

Generowane i diagramy sekwencji UML

Istnieją dwa rodzaje diagramy sekwencji: ręcznie utworzone w projekcie modelowania UML i tych, które są generowane na podstawie kodu programu.Można użyć UmlMode właściwość, aby odkryć, w jaki rodzaj diagramu sekwencji pracujesz z.

Na przykład, jeśli chcesz wprowadzić polecenie menu, który jest tylko widoczne na diagramach sekwencji UML a następnie QueryStatus() metoda może zawierać następującą instrukcję:

    command.Enabled = command.Visible = 
          sequenceDiagram != null && sequenceDiagram.UmlMode;

W wygenerowanym sekwencji diagramu, życia, wiadomości i inne elementy są prawie tak samo jak na diagramie sekwencji UML.W modelu UML w magazynie modelu ma główny, który jest Model, który jest właścicielem wszystkich innych elementów; ale generowanych interakcji istnieje we własnym magazynie modelu ma wartość null główne:

    IModel rootModel = sequenceDiagram.ModelStore.Root;
    // !sequenceDiagram.UmlMode == (rootModel == null)

Do tworzenia i wyświetlania interakcji

Tworzenie interakcji jako element podrzędny pakietu lub modelu.

Na przykład jeśli rozwijają się polecenie, które mogą być wykonywane w diagramie sekwencji puste, należy zawsze należy zacząć od sprawdzania, czy interakcja istnieje.

public void Execute (IMenuCommand command)
{
    ISequenceDiagram sequenceDiagram = 
         Context.CurrentDiagram as ISequenceDiagram;
    if (sequenceDiagram == null) return;
    // Get the diagram's interaction:
    IInteraction interaction = sequenceDiagram.Interaction;
    // A new sequence diagram might have no interaction:
    if (interaction == null)
    {
       // Get the home package or model of the diagram:
       IPackage parentPackage = sequenceDiagram.GetObject<IPackage>();
       interaction = parentPackage.CreateInteraction();
       // Display the interaction on the sequence diagram:
       sequenceDiagram.Bind(interaction);
    }

Aktualizowanie interakcji i jego układ

Podczas aktualizowania interakcji zawsze kończy operację poprzez aktualizację jego układ, za pomocą jednej z następujących metod:

ISequenceDiagram.UpdateShapePositions() Dopasowuje położenie kształtów, które niedawno został wstawiony lub przeniesiony i ich sąsiadujących kształtów.
ISequenceDiagram.Layout([SequenceDiagramLayoutKinds])odrysowania całego diagramu.Aby określić położenia życia lub wiadomości, można użyć parametru.

Jest to szczególnie ważne podczas wstawiania nowych elementów lub przenoszenie istniejących elementów.Nie będą poprawne pozycji na diagramie, dopóki nie wykonano jedną z tych operacji.Potrzeba wywołania jednej z tych operacji na raz, na koniec szereg zmian.

Aby uniknąć bemusing użytkownika, który wykonuje Cofnij po polecenia, należy użyć ILinkedUndoTransaction , należy ująć zmiany i wersja ostateczna Layout() lub UpdateShapePositions() operacji.Na przykład:

using (ILinkedUndoTransaction transaction = LinkedUndoContext.BeginTransaction("create loop"))
{
  Interaction.CreateCombinedFragment(InteractionOperatorKind.Loop, messages);
  Diagram.UpdateShapePositions();
  transaction.Commit();
}

Aby użyć ILinkedUndoTransaction, musi oświadczenia w klasie:

[Import] ILinkedUndoContext LinkedUndoContext { get; set; }

Aby uzyskać więcej informacji, zobacz Jak: łącze Aktualizacje modelu przy użyciu transakcji.

Tworzenie interakcji

Aby utworzyć linie życia

ILifeline lifeline = interaction.CreateLifeline();

Kształt linia życia reprezentuje element składnika, oznacza to wystąpienie typu.Na przykład jeśli interakcji jest używany, aby pokazać, jak składnik deleguje wiadomości przychodzące do jej części wewnętrznych, życia może reprezentować portów i części składnika:

foreach (IConnectableElement part in 
            component.Parts
           .Concat<IConnectableElement>(component.OwnedPorts))
{
   ILifeline lifeline = interaction.CreateLifeline();
   lifeline.Represents = part;
}

Alternatywnie, jeśli interakcji zawiera dowolnego zestawu obiektów, można utworzyć właściwości lub innych IConnectableElement w sobie interakcji:

ILifeline lifeline = interaction.CreateLifeline();
IProperty property1 = interaction.CreateProperty();
property1.Type = model.CreateInterface();
property1.Type.Name = "Type 1";
lifeline.Represents = property1;

Jako alternatywa dalsze można ustawić nazwę i typ kształtu Linia życia bez łączenia do elementu składnika:

ILifeline lifeline = interaction.CreateLifeline();
lifeline.Name = "c1";
lifeline.SetInstanceType("Customer");
System.Diagnostics.Debug.Assert(
           lifeline.GetDisplayName() == "c1:Customer"  );

Aby utworzyć wiadomości

Aby utworzyć komunikat, należy określić wstawiania punktów życia źródłowej i docelowej.Na przykład:

interaction.CreateMessage( sourceInsertionPoint, 
                           targetInsertionPoint, 
                           MessageKind.Complete, 
                           MessageSort.ASynchCall)

Aby utworzyć komunikat, który zawiera niezdefiniowane źródłowego lub docelowego niezdefiniowane:

interaction.CreateLostFoundMessage(MessageKind.Found, insertionPoint);

Istnieje kilka wiadomości, które można użyć do wstawiania punkty te identyfikują elementy na wszystkich najważniejszych punktów na linii życia:

Metoda ILifeline	Za jego pomocą wstawić w tym momencie
FindInsertionPointAtTop()	Górnej linii życia.
FindInsertionPointAtBottom()	Dolnej linii życia.
FindInsertionPointAfterMessage (IMessage previous)	Punkt natychmiast po określonej wiadomości.
FindInsertionPointAfterExecutionSpecification (IExecutionSpecification previous)	Punkt może być na linii życia lub blok specyfikacji wykonanie nadrzędnej.
FindInsertionPointAfterInteractionUse (IInteractionUse previous)	Punkt następującego wykorzystania przez interakcję.
FindInsertionPointAfterCombinedFragment (ICombinedFragment previous)	Punkt następującego fragmentu połączone.
FindInsertionPoint(IExecutionSpecification block)	Góry bloku wykonanie.
FindInsertionPoint(IInteractionOperand fragment)	Góry operand Scalonej fragmentu.

Podczas tworzenia wiadomości podejmuje starania w celu uniknięcia Definiowanie komunikat, który będzie krzyżują się kolejny komunikat.

Aby utworzyć Scalonej fragmenty i zastosowań interakcji

Określając punkt wstawiania na każdej linii życia, które muszą być objęte elementu, można utworzyć Scalonej fragmenty i używa interakcji.Należy zadbać, aby uniknąć, określając zestaw punktów, które byłyby krzyżują się istniejącą wiadomość lub fragmentu.

Interaction.CreateCombinedFragment(InteractionOperatorKind.Loop, 
  Interaction.Lifelines.Select(lifeline => lifeline.FindInsertionPointAtTop()));
Interaction.CreateInteractionUse(
  Interaction.Lifelines.Select(lifeline => lifeline.FindInsertionPointAtTop()));

Można również utworzyć Scalonej fragment, który obejmuje istniejący zestaw komunikatów.Wiadomości muszą wszystkie odbywać na tej samej linii życia lub wykonanie bloku.

ICombinedFragment cf = Interaction.CreateCombinedFragment(
  InteractionOperatorKind.Loop,
  Interaction.Lifelines.First().GetAllOutgoingMessages());

Fragment Scalonej zawsze jest tworzony z pojedynczym operandzie.Aby utworzyć nowy argument, należy określić istniejących operand, który ma zostać wstawiony przed lub po i czy chcesz wstawić po nim lub przed nim:

// Create an additional operand before the first
cf.CreateInteractionOperand(cf.Operands.First(), false);
// Create an additional operand after the last:
cf.CreateInteractionOperand(cf.Operands.Last(), true);

Rozwiązywanie problemów

Kształty będą wyświetlane w niepoprawnych miejscach, jeśli zmiany nie zostaną ukończone z UpdateShapePositions() lub Layout() operacji.

Inne problemy są powodowane przez punkty wstawiania jest nieprawidłowo wyrównany, tak aby nowe wiadomości lub fragmentów musiałaby krzyżują się z innymi.Symptomy może być, że odbywa się bez zmian lub wyjątek.Wyjątek nie może zostać wygenerowany aż do UpdateShapePositions() lub Layout() operacja jest wykonywana.